Software Engineering

1)What is software?
A software system usually consists of a number of separate programs,
configuration files, which are used to set up these programs, system
documentation, which describes the structure of the system, and user
documentation, which explains how to use the system and web sites for
users to download recent product information.
2)What is software engineering?
Software engineering is an engineering discipline which is concerned
with all aspects of software production.
3)What is the difference between software engineering and computer
science?
software engineering is concerned with all aspects of computer-based
systems development, including hardware, software and process
engineering. Software engineering is part of this process.
4)What is a software process?
A software process is the set of activities and associated results that
produce a software product. There are four fundamental process
activities (covered later in the book) that are common to all software
processes. These are:
1.Software specification where customers and engineers define the
software to be produced and the constraints on its operation.
2. Software development where the software is designed and
programmed.
3. Software validation where the software is checked to ensure that it is
what the customer requires.
4. Software evolution where the software is modified to adapt it to
changing customer and market requirements.
5)For a software to be classified as good, it must possess some key
features.
1. Functionality: A good software must be able to do what it was
designed to do. The software requirements must guide the design and
implementation of the software.
2. Usability: The software must be usable; the users must not find it
difficult to figure out how a good software works. A good software is
user-centered and user-friendly.
3. Efficiency: Efficiency means that perform it's operations with
minimal time and processing power. A good software uses the least
amount of processing power and memory needed to achieve the desired
result.
4. Maintainability: A good software must evolve with changing
requirements.
5. Security: A good software must be secure. It should not cause
physical or economic damage in the event of a system failure.
Unauthorized users must not be allowed access to the system.
6. Reliability: A reliable system will rarely fail, and even when it does
fail, there are recovery mechanisms in the software to recover from the
failure with minimal losses.
6)What Are the Key Challenges Facing Software Engineering?
Software engineering in the 21st century faces three key challenges:
1. The legacy challenge: The majority of software systems which are in
use today were developed many years ago yet they perform critical
business functions. The legacy challenge is the challenge of maintaining
and updating this software in such a way that excessive costs are
avoided and essential business services continue to be delivered.
2. The heterogeneity challenge: Increasingly, systems are required to
operate as distributed systems across networks that include different
types of computer and with different kinds of support systems. The
heterogeneity challenge is the challenge of developing techniques to
build dependable software which is flexible enough to cope with this
heterogeneity.
3. The delivery challenge: Many traditional software engineering
techniques are time-consuming. The time they take is required to
achieve software quality. However, businesses today must be responsive
and change very rapidly. Their supporting software must change equally
rapidly. The delivery challenge is the challenge of shortening delivery
times for large and complex systems without compromising system
quality.
7)What is SDLC?
SDLC is a systematic process for building software that ensures the
quality and correctness of the software built. SDLC process aims to
produce high-quality software that meets customer expectations. The
system development should be complete in the pre-defined time frame
and cost. SDLC consists of a detailed plan which explains how to plan,
build, and maintain specific software. Every phase of the SDLC life
Cycle has its own process and deliverables that feed into the next phase.
SDLC stands for Software Development Life Cycle and is also referred
to as the Application Development life-cycle.
8)Why SDLC?
Here, are prime reasons why SDLC is important for developing a
software system.
1. It offers a basis for project planning, scheduling, and estimating
2. Provides a framework for a standard set of activities and deliverables
3. It is a mechanism for project tracking and control
4. Increases visibility of project planning to all involved stakeholders of
the development process
5.Increased and enhance development speed
6.Improved client relations
7. Helps you to decrease project risk and project management plan
overhead SDLC Phases

9)The entire SDLC process divided into the following stages:

Phase 1: Requirement collection and analysis.
Phase 2: Feasibility study.
Phase 3: Design.
Phase 4: Coding/Implementation.
Phase 5: Testing.
Phase 6: Installation/Deployment.
Phase 7: Maintenance.

Phase 1: Requirement collection and analysis

The requirement is the first stage in the SDLC process. It is conducted
by the senior team members with inputs from all the stakeholders and
domain experts in the industry. Planning for the quality assurance
requirements and recognization of the risks involved is also done at this
stage.
This stage gives a clearer picture of the scope of the entire project and
the anticipated issues, opportunities, and directives which triggered the
project. Requirements Gathering stage need teams to get detailed and
precise requirements. This helps companies to finalize the necessary
timeline to finish the work of that system.
Phase 2: Feasibility study
Once the requirement analysis phase is completed the next sdlc step is to
define and document software needs. This process conducted with the
help of 'Software Requirement Specification' document also known as
'SRS' document.
It includes everything which should be designed and developed during
the project life cycle.
There are mainly five types of feasibilities checks:
Economic: Can we complete the project within the budget or not?
Legal: Can we handle this project as cyber law and other regulatory
framework/compliances.
Operation feasibility: Can we create operations which is expected by the
client?
Technical: Need to check whether the current computer system can
support the software
Schedule: Decide that the project can be completed within the given
schedule or not.
Phase 3: Design
In this third phase, the system and software design documents are
prepared as per the requirement specification document. This helps
define overall system architecture. This design phase serves as input for
the next phase of the model.
Phase 4: Coding/Implementation
Once the system design phase is over, the next phase is coding. In this
phase, developers start build the entire system by writing code using the
chosen programming language. In the coding phase, tasks are divided
into units or modules and assigned to the various developers. It is the
longest phase of the Software Development Life Cycle process. In this
phase, Developer needs to follow certain predefined coding guidelines.
They also need to use programming tools like compiler, interpreters,
debugger to generate and implement the code.
Phase 5: Testing
Once the software is complete, and it is deployed in the testing
environment. The testing team starts testing the functionality of the
entire system. This is done to verify that the entire application works
according to the customer requirement. During this phase, QA and
testing team may find some bugs/defects which they communicate to
developers. The development team fixes the bug and send back to QA
for a re-test. This process continues until the software is bug-free, stable,
and working according to the business needs of that system.
Phase 6: Installation/Deployment
Once the software testing phase is over and no bugs or errors left in the
system then the final deployment process starts. Based on the feedback
given by the project manager, the final software is released and checked
for deployment issues if any.
Phase 7: Maintenance
Once the system is deployed, and customers start using the developed
system, following 3 activities occur
Bug fixing - bugs are reported because of some scenarios which are not
tested at all
Upgrade - Upgrading the application to the newer versions of the
Software
Enhancement - Adding some new features into the existing software
The main focus of this SDLC phase is to ensure that needs continue to
be met and that the system continues to perform as per the specification
mentioned in the first phase.

Waterfall Model:
Winston Royce introduced the Waterfall Model in 1970.This model has
five phases: Requirements analysis and specification, design,
implementation and unit testing, integration and system testing, and
operation and maintenance. The steps always follow in this order and do
not overlap. The developer must complete every phase before the next
phase begins. This model is named "Waterfall Model", because its
diagrammatic representation resembles a cascade of waterfalls.
1. Requirements analysis and specification phase: The aim of this phase
is to understand the exact requirements of the customer and to document
them properly. Both the customer and the software developer work
together so as to document all the functions, performance, and interfacing
requirement of the software. It describes the "what" of the system to be
produced and not "how." In this phase, a large document called Software
Requirement Specification (SRS) document is created which contained a
detailed description of what the system will do in the common language.
2. Design Phase: This phase aims to transform the requirements gathered
in the SRS into a suitable form which permits further coding in a
programming language. It defines the overall software architecture
together with high level and detailed design. All this work is documented
as a Software Design Document (SDD).
3. Implementation and unit testing: During this phase, design is
implemented. If the SDD is complete, the implementation or coding phase
proceeds smoothly, because all the information needed by software
developers is contained in the SDD. During testing, the code is thoroughly
examined and modified. Small modules are tested in isolation initially.
After that these modules are tested by writing some overhead code to
check the interaction between these modules and the flow of intermediate
output.
4. Integration and System Testing: This phase is highly crucial as the
quality of the end product is determined by the effectiveness of the testing
carried out. The better output will lead to satisfied customers, lower
maintenance costs, and accurate results. Unit testing determines the
efficiency of individual modules. However, in this phase, the modules are
tested for their interactions with each other and with the system.
5. Operation and maintenance phase: Maintenance is the task performed
by every user once the software has been delivered to the customer,
installed, and operational.

When to use SDLC Waterfall Model?

Some Circumstances where the use of the Waterfall model is most suited
are:
• When the requirements are constant and not changed regularly.
• A project is short
• The situation is calm
• Where the tools and technology used is consistent and is not
changing
• When resources are well prepared and are available to use.
Advantages of Waterfall model
• This model is simple to implement also the number of resources that
are required for it is minimal.
• The requirements are simple and explicitly declared; they remain
unchanged during the entire project development.
• The start and end points for each phase is fixed, which makes it easy
to cover progress.
• The release date for the complete product, as well as its final cost,
can be determined before development.
• It gives easy to control and clarity for the customer due to a strict
reporting system.

What is Iterative waterfall model?

In practice, it is not possible to strictly follow the classical waterfall
model for software development work. In this context, we can view the
iterative waterfall model as making necessary changes to the classical
waterfall model so that it becomes applicable to practical software
development projects. The feedback paths allow for correction of the
errors committed during a phase, as and when these are detected in a later
phase.
For example, if during a testing a design error is identified, then the
feedback path allows the design to be reworked and the changes to be
reflected in the design documents. However, observe that there is no
feedback path to the feasibility stage. This means that the feasibility study
errors cannot be corrected.
The iterative waterfall model is the most widely used software
development model evolved so far.
When to use Iterative Waterfall Model
• The requirement of the defined and clearly understood.
• New technology is being learned by the development team.
• There are some high risk features and goals which might in the
future.
Application of Iterative Waterfall Model
• Major requirements are defined but the minor details might involve
when time goes.
• New technologies are being used and there is a learning curve for
the programmers to learn.
• Resource are limited to do a huge project as if a small project
automates are in contact rather than permanent.
• Very high risk as a goal of the project might change from time to
time.
Advantages of Iterative Waterfall Model
• Feedback Path: iterative waterfall allows the mechanism of error
connection because there is a feedback path from one phase to its
preceding phase which it lacks in the Waterfall Model.
• Simple: iterative waterfall model is simple to understand and use.
It is the most widely used software development model evolved so
far.
• Parallel development: can be done.

Disadvantage of Iterative Waterfall Model

• More resource: may be required to implement the iterative
waterfall model.
 • Difficult to include change requests: In the iterative waterfall
model, all the requirements must be clearly defined before starting
of the development phase but sometimes customer requirement
changes which is difficult to incorporate change requests that are
made after development phase starts.
• Not support Intermediate delivery: Project has to be fully
completed before it delivered to the customer.
• Risk handling: Project is prone to many types of risk but there is
no risk handling mechanism.
• Not suitable for a small project.

Evolutionary Model
Evolutionary model is also referred to as the successive versions model
and sometimes as the IncrementalModel .
In Evolutionary model, the software requirement is first broken down into
several modules (or functional units) that can be incrementally
constructed and delivered The development first develops the core
modules of the system. The core modules are those that do not need
services from the other modules. The initial product skeleton is refined
into increasing levels of capability by adding new functionalities in
successive versions. Each evolutionary model may be developed using an
iterative waterfall model of development. The evolutionary model is
normally useful for very large products, where it is easier to find modules
for incremental implementation. Often, evolutionary model is used when
the customer prefers to receive the product in increments so that he can
start using the different features as and when they are developed rather
than waiting all the time for the full product to be developed and delivered.
Advantages of Evolutionary Model
• Large project: Evolutionary model is normally useful for very large
products. User gets a chance to experiment with a partially
developed software much before the complete version of the system
is released.
• Evolutionary model helps to accurately elicit user requirements
during the delivery of different versions of the software.
• The core modules get tested thoroughly, thereby reducing the
chances of errors in the core modules of the final products.
• Evolutionary model avoids the need to commit large resources in
one go for development of the system.

Disadvantages of Evolutionary Model

Difficult to divide the problem into several versions that would be
acceptable to the customer and which can be incrementally implemented
and delivered.

Spiral Model
What is Spiral Model?
The spiral model is a software process model that couples the iterative
nature of prototyping with the controlled and systematic aspects of the
linear sequential model.
Barry Boehm mentioned the Spiral model in this paper (1986). The
spiral model is also known as #MetaModel since it encompasses all
other life cycle models.
Spiral Model Quadrant (Phases) The following activities are carried out
during each phase of a spiral model.
First Quadrant (Objective Setting)
– Identify the objectives of the phase.
– Examine the risks associated with these objectives.
Second Quadrant (Risk Assessment and Reduction)
– A detailed analysis is carried out for each identified project risk.
– Steps are taken to reduce the risks.
Third Quadrant (Development and Validation)
– Develop and validate the next level of the product after resolving the
identified risks.
Fourth Quadrant (Review and Planning)
– Review the results achieved so far with the customer and plan the next
iteration.
– Progressively more complete version of the software gets built with
each iteration around the spiral.

When to use Spiral Model

• The spiral model is suitable for the development of technically
challenging software products that are prone to several kinds of
risks.
• When there is complexity in requirements and need frequent
evaluation.
Advantages of Spiral Model Suitable for large projects:
• It is suggested to use the spiral model for large and complex
projects.
 • Rish handling capability: Project which is complex and large are
prone to unknown risk and error. So, the spiral model is suitable
under these high-risk environments.
• New requirement: Based on the feedback, the requirements are
redefined.

Disadvantages of Spiral Model

• Complex: It is one of the most complex SDLC models.
• Documentation: is more as it has many loop iteration.
• Expensive: It is not suitable for small projects.
• Management: is more complex.