Software unit-1

What is a Software?
Software is a collection of instructions, data, or computer programs that are
used to run machines and carry out particular activities. It is the antithesis of
hardware, which refers to a computer’s external components. A device’s
running programs, scripts, and applications are collectively referred to as
“software” in this context.
Characterstics of software➔
The characteristics of the software include:
• It is intangible, meaning it cannot be seen or touched.
• It is non-perishable, meaning it does not degrade over time.
• It is easy to replicate, meaning it can be copied and distributed easily.
• It can be complex, meaning it can have many interrelated parts and
features.
• It can be difficult to understand and modify, especially for large and
complex systems.
• It can be affected by changing requirements, meaning it may need to be
updated or modified as the needs of users change.
• It can be impacted by bugs and other issues, meaning it may need to be
tested and debugged to ensure it works as intended.

Software process➔
Software process is a set of sequence activities used to produce a software
product. If the activities are performed properly in accordance with the
ordering constraints, the desired result is produced. This desired result is
high quality software at low cost. The main purpose of the process is to
improve the quality of product.

Software product→ in the context of software engineering, product includes

any software which is manufactured on the basis of customers requirements.
This can be problem solving software or computer system. It can be said that
product is the result of project.

Difference b/w software product and process

1. Product focuses on the final Process focus on completing each
result. step being developed.
Product tends to be a short term Process tends to be a long term
aspect. aspect.
Product follows the firm guidelines. Process follows guidelines
consistency.
The goal of the product is to The goal of the process is to
complete the work successfully improve the quality of project.
 Product is created based on the Process serves as a model for
needs and expectations of the producing various goods in a similar
customers. way.
Software product depends on the It is more important than software
software process for its stability, product.
quality and control.

Software engineering➔
Software engineering is the engineering whose goal is to develop cost
effective system software.
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.
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.

Software crisis➔
Software Crisis is a term used in early days of computer science for the
difficulty of writing useful and efficient computer programs in the required
time. The software crisis was due to using the same workforce, same
methods, and same tools even though rapidly increasing software demand,
the complexity of software, and software challenges. With the increase in
software complexity, many software problems arise because existing
methods were insufficient.
Causes of Software Crisis:
• The cost of owning and maintaining software was as expensive as
developing the software.
• At that time Projects were running overtime.
• At that time Software was very inefficient.
• The quality of the software was low quality.
• Software often did not meet user requirements.
• At that time Software was never delivered.
• Non-optimal resource utilization.
• Challenging to alter, debug, and enhance.
• The software complexity is harder to change.
• Lack of communication between the software developers and its users.
•

Solution of Software Crisis:

There is no single solution to the crisis. One possible solution to a software
crisis is Software Engineering because software engineering is a systematic,
disciplined, and quantifiable approach. For preventing software crises, there
are some guidelines:
• Reduction in software over budget.
• The quality of the software must be high.
• Less time is needed for a software project.
• Experienced and skilled people working on the software project.
• Software must be delivered.
• Software must meet user requirements.

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. With the software development life
cycle, the process of software design is divided into small parts, which
makes the problem more understandable and easier to solve.
The goal of the SDLC life cycle model is to deliver high-quality, maintainable
software that meets the user’s requirements.

Stages of the Software Development Life Cycle

SDLC specifies the task(s) to be performed at various stages by a software
engineer or developer. 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 coding/implementation➔ in this phase the fundamental

development of product starts. In this phase the work is divided into modules/units
and the real code is provided. In this phase the developers use programming
languages as per the design in DDS.

Stage-5 testing➔ after the code is developed it is tested against the

requirements to make sure that the product is actually solving the needs addressed
and gathered during the requirement phase.

Stage-6 deployments and maintenance➔ once the customer starts using

the developed system then the actual problem comes that needs to be solved time-
to-time.
Waterfall Model➔
The classical waterfall model is the basic software development life
cycle model. Earlier this model was very popular but nowadays it is not used.
However, it is very important because all the other software development life
cycle models are based on the classical waterfall model.
Phases➔

The Waterfall Model has six phases which are:

1. 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.
2. 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.
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 module is done after they have been coded and unit tested.
Integration of various modules is carried out by several steps. During each integration step,
each module is added into partial 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.

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 the SDLC Waterfall Model
Prototype model➔
The Prototyping Model is one of the most popularly used Software
Development Life Cycle Models (SDLC models). This model is used when
the customers do not know the exact project requirements beforehand. In
this model, a prototype of the end product is first developed, tested, and
refined as per customer feedback repeatedly till a final acceptable prototype
is achieved which forms the basis for developing the final product.

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, here the program is run regularly to prevent failures.

Advantages of Prototyping Model

• The customers get to see the partial product early in the life cycle. This
ensures a greater level of customer satisfaction and comfort.
• New requirements can be easily accommodated as there is scope for
refinement.
• Missing functionalities can be easily figured out.
• Errors can be detected much earlier thereby saving a lot of effort and
cost, besides enhancing the quality of the software.
• The developed prototype can be reused by the developer for more
complicated projects in the future.
• Flexibility in design.
• Early feedback from customers and stakeholders can help guide the
development process and ensure that the final product meets their needs
and expectations.
• Prototyping can help reduce the risk of project failure by identifying
potential issues and addressing them early in the process.
Disadvantages of the Prototyping Model
• Costly concerning time as well as money.
• There may be too much variation in requirements each time the prototype
is evaluated by the customer.
• Poor Documentation due to continuously changing customer
requirements.
• It is very difficult for developers to accommodate all the changes
demanded by the customer.
• There is uncertainty in determining the number of iterations that would be
required before the prototype is finally accepted by the customer.
• After seeing an early prototype, the customers sometimes demand the
actual product to be delivered soon.
• Developers in a hurry to build prototypes may end up with sub-optimal
solutions.
• The customer might lose interest in the product if he/she is not satisfied
with the initial prototype.
• The prototype may not be scalable to meet the future needs of the
customer.

Incremental Model
Incremental Model is a process of software development where requirements divided into
multiple standalone modules of the software development cycle. In this model, each module
goes through the requirements, design, implementation and testing phases. Every subsequent
release of the module adds function to the previous release. The process continues until the
complete system achieved.
The various phases of incremental model are as
follows:
1. Requirement analysis: In the first phase of the incremental model, the product analysis
expertise identifies the requirements. And the system functional requirements are understood
by the requirement analysis team. To develop the software under the incremental model, this
phase performs a crucial role.

2. Design & Development: In this phase of the Incremental model of SDLC, the design of
the system functionality and the development method are finished with success. When
software develops new practicality, the incremental model uses style and development phase.

3. Testing: In the incremental model, the testing phase checks the performance of each
existing function as well as additional functionality. In the testing phase, the various methods
are used to test the behavior of each task.

4. Implementation: Implementation phase enables the coding phase of the development

system. It involves the final coding that design in the designing and development phase and
tests the functionality in the testing phase. After completion of this phase, the number of the
product working is enhanced and upgraded up to the final system product
Advantages of 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 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 duration of 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.