Unit1 : Introduction to Software Engineering?

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.

The main goal of Software Engineering is to develop software applications for improving
quality, budget, and time efficiency.

Software Characteristics – Software Engineering

There are 6 components of Software Characteristics are discussed here.

1. Functionality

The functionality of software refers to its ability to perform and function according to design
specifications. In simple terms, software systems should function correctly, i.e. perform all the functions
for which they are designed.
The functions refer to the features that the end user, as well as the business, expect as basic facilities from
the system. All these functions must be integrated into the system. Many software applications out there
are designed for simplicity, but ultimately, the purpose of the software is to provide its users with the
desired functionality. In order to look like the best software product, it must have a clear appearance,
components, and functions. However, there are also those products out there that can provide a great deal
of value for your money.

2. Usability (User-friendly)

The user-friendliness of the software is characterized by its ease of use. In other words, learning how to
use the software should require less effort or time. Navigating the software is extremely important since it
helps determine the journey the user takes within the software. This is imperative to ensure visitors
remain on your website and have a positive experience, which leads to an increase in sales and brand
loyalty.

An important indicator of a good piece of software is its user interface, i.e., the smooth flow of its design.
A product with a great UI (User Interface) design is more likely to get noticed than one without. If a
software program isn’t user-friendly, users may have trouble navigating the software and using some of
its features. Software should require less time or effort to learn. Ideally, software should be easy to use
even by people with no IT experience.

3. Efficiency

Essentially, it refers to the software’s ability to utilize human and system resources such as time, effort,
CPU, memory, computation power, network bandwidth, files, databases, etc., as effectively and
efficiently as possible. For a software project to succeed, efficiency is crucial. In addition to meeting the
needs for which the software was made, it must also provide excellent features designed to assist users in
completing their tasks faster. Software should make efficient use of storage space and execute commands
according to timing requirements.

In order to be efficient, software must offer users proper value in terms of their time and cash. The market
is filled with products that cater to various industries, but only a handful of products are efficient enough
to benefit individuals and businesses. The medical billing software that Open Practice Solutions provides,
for instance, makes billing processes much more efficient for clients than those offered by other
companies.

4. Flexibility

Software Flexibility refers to the ability of the software solution to adapt to potential or future changes in
its requirements. When evaluating the flexibility of software, look at how simple it is to add, modify, or
remove features without interfering with the current operation.
It is essential to keep up with rapidly changing markets, technologies, and customer needs. In software
development, change is inevitable; it can arise during the development process itself or as the result of
future requirements. Flexibility is therefore highly valued. Consequently, any software product must be
scalable, flexible, and easily adaptable to future technology. When designing or building a software
product, be sure to plan for these changes that are inevitably going to occur. Loose coupling of
components is the key to creating highly flexible systems.

5. Reliability

The reliability of a software product describes the likelihood it will operate without failure over a
specified period of time under certain conditions. It determines the ability of software to maintain its level
of performance (provide desired functionality) under specified conditions for a specified period of time.
Generally speaking, software reliability is measured as the availability of the software. The value should
not be less than 99%. In reliability testing, the goal is not perfection, but achieving a level of reliability
that is acceptable before a software product is released to customers. MTTF, MTTR, MTBR, etc., are
some reliability metrics that can be used to quantify the reliability of a software product.

It is regarded as one of the most important quality aspects of software quality, along with functionality,
efficiency, maintainability, etc. Since software tends to be complex, it is hard to achieve software
reliability.

6. Maintainability

Maintainability refers to how easily you can repair, improve and comprehend software code. In some
ways, maintaining is similar to being flexible. Maintainability deals with the modification of errors and
minor alterations to software code, while flexibility focuses on major functional extensions. It also
involves maintaining the services and functionality of the software.

Most of the time, developers are not the ones who maintain the software. Therefore, good documentation
is crucial, which includes code documentation, interface definitions, etc. The maintainability of software
products is affected by the quality of the documentation. Typically, more than half of development
budgets are spent on software maintenance. Maintenance should therefore be integrated into the
development lifecycle for effective software maintenance.
7. Portability

Software portability is a critical factor that cannot be ignored. Portability refers to the ability to use
software in different environments. This is the ease with which software can be ported from one platform
to another without (or with minimal) changes, while obtaining similar results. As simple as it may sound,
it refers to the ability of software to work on different hardware platforms without any (or little)
modifications needed.

Furthermore, you should be aware that porting software to a new environment is comparatively cheaper
than developing an equivalent application from scratch. There can be no doubt that portability is a crucial
aspect of reducing development costs.

8. Integrity

There are multiple interpretations of software integrity. Some people tend to associate integrity with
security, believing it is resistant to hacks and privacy violations. To others, high integrity means that the
software cannot be modified without authorization.

Integrity is key for demonstrating the safety, security, and maintainability of your software. In addition,
software that needs to be compliant with industry regulations and coding standards requires high code
integrity. Achieving software integrity can be difficult. Yet, with the right practices to improve safety,
security, and maintainability, the challenge can be easily overcome. In these days of increased security
threats, all software must include this factor.

Layered Technology in Software Engineering

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

What is a software process model?

A software process model is an abstraction of the software development process. The models specify the
stages and order of a process. So, think of this as a representation of the order of activities of the process
and the sequence in which they are performed.

A model will define the following:

 The tasks to be performed

 The input and output of each task
 The pre and post-conditions for each task
 The flow and sequence of each task

The goal of a software process model is to provide guidance for controlling and coordinating the tasks to
achieve the end product and objectives as effectively as possible.
There are many kinds of process models for meeting different requirements. We refer to these as SDLC
models (Software Development Life Cycle models). The most popular and important SDLC models are
as follows:

 Waterfall model
 V model
 Incremental model
 RAD model

 Agile model
 Iterative model
 Prototype model
 Spiral model

Factors in choosing a software process

Choosing the right software process model for your project can be difficult. If you know your
requirements well, it will be easier to select a model that best matches your needs. You need to keep the
following factors in mind when selecting your software process model:

Project requirements

Before you choose a model, take some time to go through the project requirements and clarify them
alongside your organization’s or team’s expectations. Will the user need to specify requirements in detail
after each iterative session? Will the requirements change during the development process?
Project size

Consider the size of the project you will be working on. Larger projects mean bigger teams, so you’ll
need more extensive and elaborate project management plans.

Project complexity

Complex projects may not have clear requirements. The requirements may change often, and the cost of
delay is high. Ask yourself if the project requires constant monitoring or feedback from the client.

Cost of delay

Is the project highly time-bound with a huge cost of delay, or are the timelines flexible?

Customer involvement

Do you need to consult the customers during the process? Does the user need to participate in all phases?

Familiarity with technology

This involves the developers’ knowledge and experience with the project domain, software tools,
language, and methods needed for development.

Project resources

This involves the amount and availability of funds, staff, and other resources.

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

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

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 include implementation involves 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.

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

Advantages of Waterfall Model

 Easy to Understand: The Classical Waterfall Model is very simple and easy to understand.
 Individual Processing: Phases in the Classical Waterfall model are processed one at a time.
 Properly Defined: In the classical waterfall model, each stage in the model is clearly defined.
 Clear Milestones: The classical Waterfall model has very clear and well-understood milestones.
 Properly Documented: Processes, actions, and results are very well documented.
 Reinforces Good Habits: The Classical Waterfall Model reinforces good habits like define-before-
design and design-before-code.
 Working: Classical Waterfall Model works well for smaller projects and projects where
requirements are well understood.

Disadvantages of Waterfall Model

 No Feedback Path: In the classical waterfall model evolution of software from one phase to
another phase is like a waterfall. It assumes that no error is ever committed by developers during
any phase. Therefore, it does not incorporate any mechanism for error correction.
 Difficult to accommodate Change Requests: This model assumes that all the customer
requirements can be completely and correctly defined at the beginning of the project, but the
customer’s requirements keep on changing with time. It is difficult to accommodate any change
requests after the requirements specification phase is complete.
 No Overlapping of Phases: This model recommends that a new phase can start only after the
completion of the previous phase. But in real projects, this can’t be maintained. To increase
efficiency and reduce cost, phases may overlap.
 Limited Flexibility: The Waterfall Model is a rigid and linear approach to software development,
which means that it is not well-suited for projects with changing or uncertain requirements. Once a
phase has been completed, it is difficult to make changes or go back to a previous phase.
 Limited Stakeholder Involvement: The Waterfall Model is a structured and sequential approach,
which means that stakeholders are typically involved in the early phases of the project
(requirements gathering and analysis) but may not be involved in the later phases (implementation,
testing, and deployment).
 Late Defect Detection: In the Waterfall Model, testing is typically done toward the end of the
development process. This means that defects may not be discovered until late in the development
process, which can be expensive and time-consuming to fix.
 Lengthy Development Cycle: The Waterfall Model can result in a lengthy development cycle, as
each phase must be completed before moving on to the next. This can result in delays and increased
costs if requirements change or new issues arise.

Incremental Process Model

The Incremental Process Model is also known as the Successive version model.

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.

Types of Incremental Model

1. Staged Delivery Model
2. Parallel Development Model
1. Staged Delivery Model
Construction of only one part of the project at a time.
2. Parallel Development Model
Different subsystems are developed at the same time. It can decrease the calendar time needed for the
development, i.e. TTM (Time to Market) if enough resources are available.

When to use the Incremental Process Model

1. Funding Schedule, Risk, Program Complexity, or need for early realization of benefits.
2. When Requirements are known up-front.
3. When Projects have lengthy development schedules.
4. Projects with new Technology.
 Error Reduction (core modules are used by the customer from the beginning of the phase and
then these are tested thoroughly).
 Uses divide and conquer for a breakdown of tasks.
 Lowers initial delivery cost.
 Incremental Resource Deployment.
5. Requires good planning and design.
6. The total cost is not lower.
7. Well-defined module interfaces are required.
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.
Advantages of the Incremental Process Model
1. Prepares the software fast.
2. Clients have a clear idea of the project.
3. Changes are easy to implement.
4. Provides risk handling support, because of its iterations.
5. Adjusting the criteria and scope is flexible and less costly.
6. Comparing this model to others, it is less expensive.
7. The identification of errors is simple.
Disadvantages of the Incremental Process Model
1. A good team and proper planned execution are required.
2. Because of its continuous iterations the cost increases.
3. Issues may arise from the system design if all needs are not gathered upfront throughout the
program lifecycle.
4. Every iteration step is distinct and does not flow into the next.
5. It takes a lot of time and effort to fix an issue in one unit if it needs to be corrected in all the units.

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.

What is the Evolutionary Model?

The Evolutionary development model divides the development cycle into smaller, incremental waterfall
models in which users can get access to the product at the end of each cycle.
1. Feedback is provided by the users on the product for the planning stage of the next cycle and the
development team responds, often by changing the product, plan, or process.
2. Therefore, the software product evolves with time.
3. All the models have the disadvantage that the duration of time from the start of the project to the
delivery time of a solution is very high.
4. The evolutionary model solves this problem with a different approach.
5. The evolutionary model suggests breaking down work into smaller chunks, prioritizing them, and
then delivering those chunks to the customer one by one.
6. The number of chunks is huge and is the number of deliveries made to the customer.
7. The main advantage is that the customer’s confidence increases as he constantly gets quantifiable
goods or services from the beginning of the project to verify and validate his requirements.
8. The model allows for changing requirements as well as all work is broken down into maintainable
work chunks.
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.
Necessary Conditions for Implementing this Model
1. Customer needs are clear and been explained in deep to the developer team.
2. There might be small changes required in separate parts but not a major change.
3. As it requires time, so there must be some time left for the market constraints.
4. Risk is high and continuous targets to achieve and report to customer repeatedly.
5. It is used when working on a technology is new and requires time to learn.
Advantages Evolutionary Model
1. Adaptability to Changing Requirements: Evolutionary models work effectively in projects when
the requirements are ambiguous or change often. They support adjustments and flexibility along the
course of development.
2. Early and Gradual Distribution: Functional components or prototypes can be delivered early
thanks to incremental development. Faster user satisfaction and feedback may result from this.
3. User Commentary and Involvement: Evolutionary models place a strong emphasis on ongoing
user input and participation. This guarantees that the software offered closely matches the needs
and expectations of the user.
4. Improved Handling of Difficult Projects: Big, complex tasks can be effectively managed with
the help of evolutionary models. The development process is made simpler by segmenting the
project into smaller, easier-to-manage portions.
Disadvantages Evolutionary Model
1. Communication Difficulties: Evolutionary models require constant cooperation and
communication. The strategy may be less effective if there are gaps in communication or if team
members are spread out geographically.
2. Dependence on an Expert Group: A knowledgeable and experienced group that can quickly
adjust to changes is needed for evolutionary models. Teams lacking experience may find it difficult
to handle these model’s dynamic nature.
3. Increasing Management Complexity: Complexity can be introduced by organizing and managing
several increments or iterations, particularly in large projects. In order to guarantee integration and
synchronization, good project management is needed.
4. Greater Initial Expenditure: As evolutionary models necessitate continual testing, user
feedback and prototyping, they may come with a greater starting cost. This may be a problem for
projects that have limited funding.

Agile Development Models – Software Engineering

What is Agile Model?
The Agile Model was primarily designed to help a project adapt quickly to change requests. So, the
main aim of the Agile model is to facilitate quick project completion. To accomplish this task, agility is
required. Agility is achieved by fitting the process to the project and removing activities that may not
be essential for a specific project. Also, anything that is a waste of time and effort is avoided. The Agile
Model refers to a group of development processes. These processes share some basic characteristics but
do have certain subtle differences among themselves.

Steps in the Agile Model

The agile model is a combination of iterative and incremental process models. The steps involve in
agile SDLC models are:
 Requirement gathering
 Design the Requirements
 Construction / Iteration
 Testing / Quality Assurance
 Deployment
 Feedback

1. Requirement Gathering:- In this step, the development team must gather the requirements, by
interaction with the customer. development team should plan the time and effort needed to build the
project. Based on this information you can evaluate technical and economical feasibility.
2. Design the Requirements:- In this step, the development team will use user-flow-diagram or high-
level UML diagrams to show the working of the new features and show how they will apply to the
existing software. Wireframing and designing user interfaces are done in this phase.
3. Construction / Iteration:- In this step, development team members start working on their project,
which aims to deploy a working product.
4. Testing / Quality Assurance:- Testing involves Unit Testing, Integration Testing, and System
Testing. A brief introduction of these three tests is as follows:
 Unit Testing:- Unit testing is the process of checking small pieces of code to ensure that the
individual parts of a program work properly on their own. Unit testing is used to test individual
blocks (units) of code.
 Integration Testing:- Integration testing is used to identify and resolve any issues that may
arise when different units of the software are combined.
 System Testing:- Goal is to ensure that the software meets the requirements of the users and
that it works correctly in all possible scenarios.
5. Deployment:- In this step, the development team will deploy the working project to end users.
6. Feedback:- This is the last step of the Agile Model. In this, the team receives feedback about the
product and works on correcting bugs based on feedback provided by the customer.

Characteristics of the Agile Process

 Agile processes must be adaptable to technical and environmental changes. That means if any
technological changes occur, then the agile process must accommodate them.
 The development of agile processes must be incremental. That means, in each development, the
increment should contain some functionality that can be tested and verified by the customer.
 The customer feedback must be used to create the next increment of the process.
 The software increment must be delivered in a short span of time.
 It must be iterative so that each increment can be evaluated regularly.
When To Use the Agile Model?
 When frequent modifications need to be made, this method is implemented.
 When a highly qualified and experienced team is available.
 When a customer is ready to have a meeting with the team all the time.
 when the project needs to be delivered quickly.
 Projects with few regulatory requirements or not certain requirements.
 projects utilizing a less-than-strict current methodology
 Those undertakings where the product proprietor is easily reachable
 Flexible project schedules and budgets.
Advantages of the Agile Model
 Working through Pair programming produces well-written compact programs which have fewer
errors as compared to programmers working alone.
 It reduces the total development time of the whole project.
 Agile development emphasizes face-to-face communication among team members, leading to
better collaboration and understanding of project goals.
 Customer representatives get the idea of updated software products after each iteration. So, it is
easy for him to change any requirement if needed.
 Agile development puts the customer at the center of the development process, ensuring that the
end product meets their needs.
Disadvantages of the Agile Model
 The lack of formal documents creates confusion and important decisions taken during different
phases can be misinterpreted at any time by different team members.
 It is not suitable for handling complex dependencies.
 The agile model depends highly on customer interactions so if the customer is not clear, then the
development team can be driven in the wrong direction.
 Agile development models often involve working in short sprints, which can make it difficult to
plan and forecast project timelines and deliverables. This can lead to delays in the project and can
make it difficult to accurately estimate the costs and resources needed for the project.
 Agile development models require a high degree of expertise from team members, as they need to
be able to adapt to changing requirements and work in an iterative environment. This can be
challenging for teams that are not experienced in agile development practices and can lead to
delays and difficulties in the project.
 Due to the absence of proper documentation, when the project completes and the developers are
assigned to another project, maintenance of the developed project can become a problem.