UNIT-I

Introduction to Software Engineering –

Software is a program or set of programs containing instructions that

provide the desired functionality. Engineering is the process of designing
and building something that serves a particular purpose and finds a cost-
effective solution to problems.

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.
1. Software engineering includes a variety of techniques, tools, and
methodologies, including requirements analysis, design, testing, and
maintenance.
2. It is a rapidly evolving field, and new tools and technologies are
constantly being developed to improve the software development
process.
3. 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.
4. Software Engineering is mainly used for large projects based on
software systems rather than single programs or applications.
5. The main goal of Software Engineering is to develop software
applications for improving quality, budget, and time efficiency.
6. 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.

Main Attributes of Software Engineering -

Software Engineering is a systematic, disciplined, quantifiable study and
approach to the design, development, operation, and maintenance of a
software system. There are four main Attributes of Software Engineering.

1. Efficiency: It provides a measure of the resource requirement of a

software product efficiently.
2. Reliability: It assures that the product will deliver the same results
when used in similar working environment.
3. Reusability: This attribute makes sure that the module can be used in
multiple applications.
4. Maintainability: It is the ability of the software to be modified, repaired,
or enhanced easily with changing requirements.

Key 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.

What Tasks do Software Engineers do?

The main responsibility of a software engineer is to develop useful

computer programs and applications. Working in teams, you would
complete various projects and develop solutions to satisfy certain
customer or corporate demands.

Some of the key responsibilities of software engineer are:

 Requirement Analysis-: Collaborating with stakeholders to

understand and gather the requirements to design and develop
software solutions.
 Design and Development-: Creating well-structured, maintainable
code that meets the functional requirements and adheres to software
design principles.
 Testing and Debugging-: Writing and conducting unit tests,
integration tests, and debugging code to ensure software is reliable
and bug-free.
 Code Review-: Participating in code reviews to improve code quality,
ensure adherence to standards, and facilitate knowledge sharing
among team members.
 Maintenance-: Updating and maintaining existing software systems,
fixing bugs, and improving performance or adding new features.
 Documentation-: Writing clear documentation, including code
comments, API documentation, and design documents to help other
engineers and future developers understand the system.

Advantages of Software Engineering

There are several advantages to using a systematic and disciplined

approach to software development, such as:

1. Improved Quality: By following established software engineering

principles and techniques, the software can be developed with fewer
bugs and higher reliability.
2. Increased Productivity: Using modern tools and methodologies can
streamline the development process, allowing developers to be more
productive and complete projects faster.
3. Better Maintainability: Software that is designed and developed using
sound software engineering practices is easier to maintain and update
over time.
4. Reduced Costs: By identifying and addressing potential problems
early in the development process, software engineering can help to
reduce the cost of fixing bugs and adding new features later on.
5. Increased Customer Satisfaction: By involving customers in the
development process and developing software that meets their needs,
software engineering can help to increase customer satisfaction.
6. Better Team Collaboration: By using agile methodologies and
continuous integration, software engineering allows for better
collaboration among development teams.
7. Better Scalability: By designing software with scalability in mind,
software engineering can help to ensure that software can handle an
increasing number of users and transactions.
8. Better Security: By following the Software Development Life Cycle
(SDLC) and performing security testing, software engineering can help
to prevent security breaches and protect sensitive data.

Disadvantages of Software Engineering

While Software Engineering offers many advantages, there are also some
potential disadvantages to consider:

1. High upfront costs: Implementing a systematic and disciplined

approach to software development can be resource-intensive and
require a significant investment in tools and training.
2. Limited flexibility: Following established software engineering
principles and methodologies can be rigid and may limit the ability to
quickly adapt to changing requirements.
3. Bureaucratic: Software Engineering can create an environment that is
bureaucratic, with a lot of processes and paperwork, which may slow
down the development process.
4. Complexity: With the increase in the number of tools and
methodologies, software engineering can be complex and difficult to
navigate.
5. Limited creativity: The focus on structure and process can stifle
creativity and innovation among developers.
6. High learning curve: The development process can be complex, and
it requires a lot of learning and training, which can be challenging for
new developers.
7. High dependence on tools: Software engineering heavily depends on
the tools, and if the tools are not properly configured or are not
compatible with the software, it can cause issues.
8. High maintenance: The software engineering process requires regular
maintenance to ensure that the software is running efficiently, which
can be costly and time-consuming.

A Generic view of process: Software engineering- a layered technology –

Software engineering is a fully layered technology, to develop software we need to
go from one layer to another. All the layers are connected and each layer demands
the fulfilment of the previous layer.

Layered technology is divided into four parts:

1. A quality focus: It defines the continuous process improvement

principles of software. It provides integrity that means providing
security to the software so that data can be accessed by only an
authorized person, no outsider can access the data. It also focuses
on maintainability and usability.
2. Process: It is the foundation or base layer of software engineering. It is
key that binds all the layers together which enables the development of
software before the deadline or on time. Process defines a framework
that must be established for the effective delivery of software engineering
technology. The software process covers all the activities, actions, and
tasks required to be carried out for software development.

Process activities are listed below:-

 Communication: It is the first and foremost thing for the development

of software. Communication is necessary to know the actual demand of
the client.
 Planning: It basically means drawing a map for reduced the
complication of development.
 Modeling: In this process, a model is created according to the client
for better understanding.
 Construction: It includes the coding and testing of the problem.
 Deployment:- It includes the delivery of software to the client for
evaluation and feedback.

3. Method: During the process of software development the answers to

all “how-to-do” questions are given by method. It has the information of all
the tasks which includes communication, requirement analysis, design
modeling, program construction, testing, and support.

4. Tools: Software engineering tools provide a self-operating system

for processes and methods. Tools are integrated which means
information created by one tool can be used by another.

Software Development Life Cycle (SDLC) –

Software development life cycle (SDLC) is a structured process that is

used to design, develop, and test good-quality software. SDLC, or
software development life cycle, is a methodology that defines the entire
procedure of software development step-by-step. The goal of the SDLC
life cycle model is to deliver high-quality, maintainable software that meets
the user’s requirements. SDLC in software engineering models outlines
the plan for each stage so that each stage of the software development
model can perform its task efficiently to deliver the software at a low cost
within a given time frame that meets users requirements.

What is the Software Development Life Cycle (SDLC)?

SDLC is a process followed for software building within a software

organization. SDLC consists of a precise plan that describes how to
develop, maintain, replace, and enhance specific software. The life cycle
defines a method for improving the quality of software and the all-around
development process.

Stages of the Software Development Life Cycle-

SDLC specifies the task(s) to be performed at various stages by a software

engineer or developer. It ensures that the end product is able to meet the
customer’s expectations and fits within the overall budget. Hence, it’s vital
for a software developer to have prior knowledge of this software
development process. SDLC is a collection of these six stages, and the
stages of SDLC are as follows:

The SDLC Model involves six phases or stages while developing any
software.

Stage-1: Planning and Requirement Analysis -

Planning is a crucial step in everything, just as in software development. In
this same stage, requirement analysis is also performed by the developers
of the organization. This is attained from customer inputs, and sales
department/market surveys.
The information from this analysis forms the building blocks of a basic
project. The quality of the project is a result of planning. Thus, in this stage,
the basic project is designed with all the available information.
Stage-2: Defining Requirements –

In this stage, all the requirements for the target software are specified.
These requirements get approval from customers, market analysts, and
stakeholders.
This is fulfilled by utilizing SRS (Software Requirement Specification). This
is a sort of document that specifies all those things that need to be defined
and created during the entire project cycle.

Stage-3: Designing Architecture

SRS is a reference for software designers to come up with the best

architecture for the software. Hence, with the requirements defined in SRS,
multiple designs for the product architecture are present in the Design
Document Specification (DDS).
This DDS is assessed by market analysts and stakeholders. After
evaluating all the possible factors, the most practical and logical design is
chosen for development.
Stage-4: Developing Product –

At this stage, the fundamental development of the product starts. For this,
developers use a specific programming code as per the design in the DDS.
Hence, it is important for the coders to follow the protocols set by the
association. Conventional programming tools like compilers, interpreters,
debuggers, etc. are also put into use at this stage. Some popular languages
like C/C++, Python, Java, etc. are put into use as per the software
regulations.

Stage-5: Product Testing and Integration

After the development of the product, testing of the software is necessary

to ensure its smooth execution. Although, minimal testing is conducted at
every stage of SDLC. Therefore, at this stage, all the probable flaws are
tracked, fixed, and retested. This ensures that the product confronts the
quality requirements of SRS.

Documentation, Training, and Support: Software documentation is an

essential part of the software development life cycle. A well-written
document acts as a tool and means to information repository necessary to
know about software processes, functions, and maintenance.
Documentation also provides information about how to use the product.
Training in an attempt to improve the current or future employee
performance by increasing an employee’s ability to work through learning,
usually by changing his attitude and developing his skills and
understanding.
Stage-6: Deployment and Maintenance of Products

After detailed testing, the conclusive product is released in phases as per

the organization’s strategy. Then it is tested in a real industrial environment.
It is important to ensure its smooth performance. If it performs well, the
organization sends out the product as a whole. After retrieving beneficial
feedback, the company releases it as it is or with auxiliary improvements to
make it further helpful for the customers. However, this alone is not enough.
Therefore, along with the deployment, the product’s supervision.

Software Development Life Cycle Models -

we have listed the SDLC models:

Classical Waterfall Model- The Waterfall Model is a classical software

development methodology. It was first introduced by Winston W. Royce in
1970. It is a linear and sequential approach to software development that
consists of several phases. It must be completed in a specific order. This
classical waterfall model is simple and idealistic. It was once very popular.
Today, it is not that popularly used. However, it is important because most
other types of software development life cycle models are a derivative of this
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.
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.
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.

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.

Incremental Process Model – Software

Engineering –
What is the Incremental Process Model?

First, a simple working system implementing only a few basic features is

built and then that is delivered to the customer. Then thereafter many
successive iterations/ versions are implemented and delivered to the
customer until the desired system is released.

A, B, and C are modules of Software Products that are incrementally

developed and delivered.
Phases of incremental model-

Requirements of Software are first broken down into several modules that
can be incrementally constructed and delivered.

1. Requirement analysis: In Requirement Analysis At any time, the plan

is made just for the next increment and not for any kind of long-term
plan. Therefore, it is easier to modify the version as per the needs of
the customer.
2. Design & Development: At any time, the plan is made just for the next
increment and not for any kind of long-term plan. Therefore, it is easier
to modify the version as per the needs of the customer. The
Development Team first undertakes to develop core features (these do
not need services from other features) of the system. Once the core
features are fully developed, then these are refined to increase levels
of capabilities by adding new functions in Successive versions. Each
incremental version is usually developed using an iterative waterfall
model of development.
3. Deployment and Testing: After Requirements gathering and
specification, requirements are then split into several different versions
starting with version 1, in each successive increment, the next version
 is constructed and then deployed at the customer site. in development
and Testing the product is checked and tested for the actual process of
the model.
4. Implementation: In implementation After the last version (version n), it
is now deployed at the client site.

Characteristics of Incremental Process Model

1. System development is divided into several smaller projects.

2. To create a final complete system, partial systems are constructed one
after the other.
3. Priority requirements are addressed first.
4. The requirements for that increment are frozen once they are created.

Evolutionary Model – Software Engineering –

The evolutionary model is a combination of the Iterative and Incremental

models of the software development life cycle. Delivering your system in a
big bang release, delivering it in incremental process over time is the
action done in this model. Some initial requirements and architecture
envisioning need to be done. It is better for software products that have
their feature sets redefined during development because of user feedback
and other factors.
Evolutionary Process Model-
The evolutionary model is based on the concept of making an initial product
and then evolving the software product over time with iterative and
incremental approaches with proper feedback. In this type of model, the
product will go through several iterations and come up when the final
product is built through multiple iterations. The development is carried out
simultaneously with the feedback during the development. This model has
a number of advantages such as customer involvement, taking feedback
from the customer during development, and building the exact product that
the user wants. Because of the multiple iterations, the chances of errors get
reduced and the reliability and efficiency will increase.
Types of Evolutionary Process Models
1. Iterative Model
2. Incremental Model
3. Spiral Model

Iterative Model
In the iterative model first, we take the initial requirements then we enhance
the product over multiple iterations until the final product gets ready. In
every iteration, some design modifications were made and some changes
in functional requirements is added. The main idea behind this approach is
to build the final product through multiple iterations that result in the final
product being almost the same as the user wants with fewer errors and the
performance, and quality would be high.

Incremental Model
In the incremental model, we first build the project with basic features and
then evolve the project in every iteration, it is mainly used for large
projects. The first step is to gather the requirements and then perform
analysis, design, code, and test and this process goes the same over and
over again until our final project is ready.
Spiral Model
The spiral model is a combination of waterfall and iterative models and in
this, we focused on risk handling along with developing the project with the
incremental and iterative approach, producing the output quickly as well as
it is good for big projects. The software is created through multiple iterations
using a spiral approach. Later on, after successive development the final
product will develop, and the customer interaction is there so the chances
of error get reduced.

Application of Evolutionary Model-

1. It is used in large projects where you can easily find modules for
incremental implementation. Evolutionary model is commonly used
when the customer wants to start using the core features instead of
waiting for the full software.
2. Evolutionary model is also used in object oriented software
development because the system can be easily portioned into units in
terms of objects.
Advantages of the Evolutionary Process Model
1. During the development phase, the customer gives feedback regularly
because the customer’s requirement gets clearly specified.
2. After every iteration risk gets analyzed.
3. Suitable for big complex projects.
4. The first build gets delivered quickly as it used an iterative and
incremental approach.
5. Enhanced Flexibility: The iterative nature of the model allows for
continuous changes and refinements to be made, accommodating
changing requirements effectively.
6. Risk Reduction: The model’s emphasis on risk analysis during each
iteration helps in identifying and mitigating potential issues early in the
development process.
7. Adaptable to Changes: Since changes can be incorporated at the
beginning of each iteration, it is well-suited for projects with evolving or
uncertain requirements.
8. Customer Collaboration: Regular customer feedback throughout the
development process ensures that the end product aligns more closely
with the customer’s needs and expectations.

Disadvantages of the Evolutionary Process Model

1. It is not suitable for small projects.
2. The complexity of the spiral model can be more than the other
sequential models.
3. The cost of developing a product through a spiral model is high.
4. roject Management Complexity: The iterative nature of the model
can make project management and tracking more complex compared
to linear models.
5. Resource Intensive: The need for continuous iteration and customer
feedback demands a higher level of resources, including time,
personnel, and tools.
6. Documentation Challenges: Frequent changes and iterations can
lead to challenges in maintaining accurate and up-to-date
documentation.
7. Potential Scope Creep: The flexibility to accommodate changes can
sometimes lead to an uncontrolled expansion of project scope,
resulting in scope creep.
8. Initial Planning Overhead: The model’s complexity requires a well-
defined initial plan, and any deviations or adjustments can be time-
consuming and costly.

Software Myths:

Most, experienced experts have seen myths or superstitions (false beliefs

or interpretations) or misleading attitudes (naked users) which creates
major problems for management and technical people. The types of
software-related myths are listed below.

The types of software-related myths are listed below.

(i) Management Myths:

Myth 1: We have all the standards and procedures available for

software development.

Fact:

Software experts do not know all the requirements for the software
development.

And all existing processes are incomplete as new software

development is based on new and
Different problem.

Myth 2: The addition of the latest hardware programs will improve the
software development.

Fact:

The role of the latest hardware is not very high on standard software
development; instead
(CASE) Engineering tools help the computer, they are more important
than hardware to produce quality and productivity.

CASE tools are set of software application programs, which are used to
automate SDLC activities. CASE tools are used by software project
managers, analysts and engineers to develop software system.

Hence, the hardware resources are misused.

Cont...

Myth 3: With the addition of more people and program planners to

Software development can help meet project deadlines (If lagging
behind).

Fact:
If software is late, adding more people will merely make the problem
worse.

This is because the people already working on the project now need to
spend time educating the newcomers, and are thus taken away from
their work.

The newcomers are also far less productive than the existing software
engineers, and so the work put into training them to work on the
software does not immediately meet with an appropriate reduction in
work.

(ii)Customer Myths:

The customer can be the direct users of the software, the technical
team, marketing / sales department, or other company. Customer has
myths leading to false expectations
(Customer) & that’s why you create dissatisfaction with the developer.

Myth 1: A general statement of Goal is enough to start writing plans

(software development) and details of objectives can be done over
time.

Fact:

Official and detailed description of the database function, ethical

performance, communication, structural issues and the verification
process are important.

Unambiguous requirements (admitting of no doubt or

misunderstanding; having only one meaning or interpretation and
leading to only one conclusion) (usually derived iteratively) are
developed only through effective and continuous communication
between customer and developer.

Cont...

Myth 2: Software requirements continually change, but change can be

easily accommodated because software is flexible

Fact:

It is true that software requirements change, but the impact of change

varies with the time at which it is introduced.
When requirements changes are requested early (before design or
code has
Been started), the cost impact is relatively small.

However, as time passes, the cost impact grows rapidly—resources

have been committed, a design framework has been established, and
change can cause disturbance that requires additional resources and
major design
Modification.

(iii)Practitioner’s Myths:

Myths 1: They believe that their work has been completed with the
writing of the plan.

Fact:

It is true that every 60-80% effort goes into the maintenance phase (as
of the latter software release). Efforts are required, where the product
is available first delivered to customers.

Myths 2: There is no other way to achieve system quality, until it is

“Running”.

Fact:

Systematic review of project technology is the quality of effective

software verification method. These updates are quality filters and
more accessible than test.

Cont...

Myth 3: An operating system is the only product that can be

successfully exported project.

Fact:

A working system is not enough, the right document brochures and

booklets are also required to provide guidance & software support.

Myth 4: Engineering software will enable us to build powerful and

Unnecessary document & always delay us.
 Fact:

Software engineering is not about creating documents. It is about

creating a quality product. Better quality leads to reduced rework. And
reduced rework results in faster delivery times

What is a Software Process Framework?

Software Process Framework details the steps and chronological order of

a process. Since it serves as a foundation for them, it is utilized in most
applications. Task sets, umbrella activities, and process framework
activities all define the characteristics of the software development
process. Software Process includes:
1. Tasks: They focus on a small, specific objective.
2. Action: It is a set of tasks that produce a major work product.
3. Activities: Activities are groups of related tasks and actions for a
major objective.

What Is a Software Development Framework?

A software development framework is a structured set of tools, libraries,
best practices, and guidelines that help developers build software
applications. Think of it as a template or foundation that provides the basic
structure and components needed for a software project.
Key Points
1. Foundation: It gives a basic structure or template for developing
software, so developers don’t have to start from scratch.
2. Components and Tools: It includes pre-built components and tools
that make development faster and easier.
3. Best Practices and Guidelines: It offers best practices and guidelines
to ensure the software is built in an organized and efficient way.
4. Customization: Developers can modify and add new functions to
customize the framework to their specific needs.
Advantages of Software Development Framework
A Software Development Framework offers numerous benefits that
streamline the software development process and enhance the quality
and efficiency of the final product. Here are some key advantages:
1. Increased Productivity: Frameworks provide pre-built components
and tools, allowing developers to focus on specific application logic
rather than reinventing the wheel.
2. Consistent Quality: By following best practices and standardized
processes, frameworks help ensure consistent code quality and
structure across the project.
3. Reduced Development Time: With ready-to-use templates and
libraries, developers can significantly cut down on the time needed to
build applications from scratch.
4. Better Maintainability: A structured framework makes the codebase
more organized and easier to understand, which simplifies
maintenance and updates.
5. Enhanced Security: Frameworks often include built-in security
features and follow industry best practices, reducing the risk of
vulnerabilities.
6. Scalability: Frameworks are designed to handle growth, making it
easier to scale applications as user demand increases.
Dis-advantages of Software Development Framework
While Software Development Frameworks offer several advantages,
they also come with certain drawbacks that developers and organizations
should consider:
1. Learning Curve: Frameworks often have a steep learning curve,
requiring developers to invest time and effort in understanding the
framework’s architecture, conventions, and best practices.
2. Restrictions: Some frameworks impose constraints and limitations on
how developers can design and implement certain features, potentially
limiting flexibility and creativity.
3. Complexity Overhead: In some cases, frameworks introduce
unnecessary complexity, especially for smaller or simpler projects,
which can lead to over-engineering.
4. Performance Overhead: Using a framework may introduce additional
layers of abstraction and overhead, which can impact the performance
of the application, particularly in resource-intensive environments.
5. Vendor Lock-in: Depending heavily on a specific framework can lead
to vendor lock-in, making it challenging to switch to alternative
technologies or frameworks in the future.