Issues in the Design of Large software

Anjali Singhal

Reg no.10801710

Roll no. C1801B40

ABSTRACT:- large software.I have also talked about main

features of a large software.
In this tem paper I have talked about the
design issue of a large software.In this I Index:-
have covered the difference model used for
making a software and after that I have 1. Introduction
specified which model is used for making a
2. Different models
large software or we can say developing a
 2.1 Water Fall Model 4.2 Code freeze

2.2 Prototype Model 5. Issues in Developing Large

Software Systems
2.3 Incremental Lifecycle
model 6. Software Crisis

2.4 Spiral Model 7. Why Writing Large

Programs is Hard
3. Process Improvement Models
8. Reasons for failure
3.1 Capability Maturity
Model Integration 9. Conclusion

3.2 ISO 9000 10. References

4. Main Features of Large

Software
1.
4.1 Feature freeze

1.

2. Introduction We have four different model or more used

When we try to design a software either
large or small we have to keep certain things
in mind and they are how reliable a software
is,is the functioning of software is same as
that we wanted or there is a bug we have to
sort out.The programmer has to keep
different crisis and risk in mind which may
come while developing the software.There
are different model for developing a
software for a large software we use a
specific model because all other model have
problems in creating the software so we use
a particular model to develop a software.
3. Different Model
for developing a software they are as
follows
2.1 Water fall model
The water fall model is also know as the top
down model. It is highly structured physical
environments in which after-the-fact
changes are prohibitively costly, if not
impossible. The main problem in water fall
model is that if we want to make any change
in our model we have to check it from the
top though we want to make any change in
middle but we have to start from the
begning.

STEP:-
Figure :- water fall model
i. Requirements:-
In this we try to gather requirement i.e the
needs require to built our software.After all
our requirement is fulfilled we move to next
step.
ii. Design:-
Here we talk about the designing part.the
design is divided into three parts Top level,
Detailed, Built from requirements.
iii. Implementation:-
Here we try to put our code to function our
software the way we want it to function.
iv. Testing code:-
This is done first by the developer and than
by the analyst who are behind the project i.e
people who are working for the project.This
is done to check whether any error has
ocuured or not.
v. Delivery:-
The software is delivered to specific
customer.
2.2 Prototype Model:-
In this model we make a constant change in
our software until the customer is satisfied
with the project we make the constant
changes the way the customer requires.
Figure :- prototype model
The model start from requirement gathering
and it move s ahead goes on for the
development of software as per the
customer satisfaction.The main falut in this
model is high costing and some time the
quality of software goes down.
2.3 Incremental lifecycle model:-
In this model we goes on updating our
software from the basic level and move
forward doing the same.
 Figure :- incremental life cycle
model
In this model the Software Requirements are
well defined, but realization may be delayed
and The basic software functionality are
required early.
2.4 Spiral model:-
The most important of all because it is used
to develop the large software.It is the most
reliable model for developing large
software. The main advantage of this model
is that it combine advantages of top-down
and bottom-up concepts. Also known as the
spiral lifecycle model.
The main structure of this model:
Figure :- spiral model
STEPS:-
The system requirements are defined in as
much detail as possible. This usually
involves interviewing a number of users
representing all the external or internal users
and other aspects of the existing system.
A preliminary design is created for the new
system. This phase is the most important
part of "Spiral Model". In this phase all
possible alternatives, which can help in
developing a cost effective project are
analyzed and strategies to use them are
decided. This phase has been added
specially in order to identify and resolve all
the possible risks in the project
development. If risks indicate any kind of
uncertainty in requirements, prototyping
may be used to proceed with the available
data and find out possible solution in order
to deal with the potential changes in the
requirements.
A first prototype of the new system is
constructed from the preliminary design.
This is usually a scaled-down system, and
represents an approximation of the
characteristics of the final product.

A second prototype is evolved by a fourfold

procedure:

1. Evaluating the first prototype in

terms of its strengths, weaknesses,
and risks.

2. Defining the requirements of the

second prototype.

3. Planning and designing the second

prototype.

4. Constructing and testing the second

prototype.

SO spiral model is most important of all the

model because it is like a circle and we
check the project after every circle is
completed so the chances of error is less so
that’s why we use this model for large
program.
4. Process Improvement
Models:
Figure :- CMMI model
The Capability Maturity Model Integration
(CMMI) is one of the leading models and
based on best practice. Independent
assessments grade organizations on how
well they follow their defined processes, not
on the quality of those processes or the
software produced. CMMI has replaced
CMM.

3.1 Capability Maturity Model

Integration

3.2 ISO 9000


Figure :- ISO 9000 model
ISO 9000 describes standards for a formally
organized process to manufacture a product
and the methods of managing and
monitoring progress. Although the standard
was originally created for the manufacturing
sector, ISO 9000 standards have been
applied to software development as well.
Like CMMI, certification with ISO 9000
does not guarantee the quality of the end
result, only that formalized business
processes have been followed.
5. MAIN FEATURES OF
LARGE SOFTWARE:-
4.1. Feature freeze:
in which all work on adding new features is
suspended, shifting the effort towards
fixing bugs and improving the user
experience. The addition of new features
may have a disruptive effect on other parts
of the program, due both to the introduction
of new, untested source code or resources
and to interactions with other features; thus,
a feature freeze helps improve the program's
stability.
4.2. Code freeze:
A code freeze, in which no changes
whatsoever are permitted to a portion or the
entirety of the program's source code.
Particularly in large software systems, any
change to the source code may
have unintended consequences, potentially
introducing new bugs; thus, a code freeze
helps ensure that a portion of the program
that is known to work correctly will
continue to do so. Code freezes are often
employed in the final stages of
development, when a particular release or
iteration is being tested, but may also be
used to prevent changes to one portion of a
program while another is undergoing
development.
6. Issues in Developing Large
Software Systems:-
1. The team members have to
communicateand interact with each
other A single software developer may
not be able to do the job in the required
amount of time, developers have to
work as a team.
2. The team member has to
communicate and interact with each
other.
3. Specification of a large software
product is more complicated than just
saying write a program that sorts a set
of integers.
 4. For a large software project one has
to carefully think about the design of
the software before starting to write
code.
5. A team of programmers have to
write different parts of the code that
will work together
6. How do we make sure that the
software does what it is supposed to
do?
7. What happens if we need to
add a new feature to the software?
7. Software Crisis:
Large Software Systems Often: Do not
provide the desired functionality, Take too
long to build, Cost too much to build,
Require too much time, space, or other
resources to run, cannot evolve to meet
changing needs.
Examples:
1. Because of software related
problems in its automated baggage-
handling system, opening of
Denver’s big, state-of-the art,
international airport was delayed
almost a year in 1993
2. NASA’s Mars Climate Orbiter was
lost in 1999 ,Cause: failed
translation of English units to metric
units
3. NASA’s Mars Sojourner software
deadlocked. Cause: Priority
inversion. Priority inversion occurs
when a process that has higher
priority is waiting for a process for a
lower priority to release a lock.
However, since the process holding
the lock has lower priority it does
not get scheduled and the system
deadlocks.
8. Why Writing Large
Programs is Hard:

1. Customer’s needs are hard to

discover and record
Software’s Chronic Crisis: 2. Customer’s needs change
with time
3. The larger the system the
more potential interactions
Three-decades later (1994) an article in among components
Scientific American by W. Wayt Gibbs was 4. Several people must
Titled: “Software’s Chronic Crisis’’ cooperate communication
complexity among people
1. For every 6 large software projects can grow.
that become operational, 2 of them Challenge in large projects:
are cancelled
2. On the average software 1. Developing large/complex
development projects overshoot their software application is very
schedule by half challenging
3. 3 quarters of the large systems do not
provide required functionality (i) Effort intensive
 (ii) High cost It is generally felt in our community, that
(iii) Long development time with each generation large detector,
(iv) Changing needs for users software is becoming a bigger and bigger
(v) High risk of failure, user acceptance, problem. If we extrapolate this trend to the
performance, maintainability SSC era, software would be a very big
problem indeed. Many people are inventing
2. Quite different from one-time or using new tools to attack the software
programs where author and user problem, but some of these tools are like
are same! aspirins, they alleviate some pain but don’t
cure the disease. We need to understand the
real causes of our current problems, before
we can find the real solutions.
9. Reasons for failure The intent of this paper is to discuss the
implications that the process of developing
a. Schedule slippage very large software or very large
information systems (VLIS) has on the
b. Cost over-runs
approach to the software engineering
c. Does not solve user’s problem. Although the same SE problems
problem are found in many domains, they take on a
unique set of constraints when considered in
d. Poor quality of software the context of developing VLIS. It is our
position that possibilities for enhancing the
e. Poor maintainability software development process are functions
f. Ad hoc software of the domain in which one participates.
development results in
such problems 11. REFRENCE:-
a) No planning of development Link:-
work (e.g. no milestones
defined) 1. http://en.wikipedia.org/wiki/Waterfal
l_model
b) Deliverables to user not
identified 2. http://en.wikipedia.org/wiki/Waterfal
c) Poor understanding of user l_model
requirements
3. http://www.softdevteam.com/Increm
d) No control or review ental-lifecycle.asp
e) Technical incompetence of 4. http://en.wikipedia.org/wiki/Spiral_
developers model
f) Poor understanding of cost
5. http://en.wikipedia.org/wiki/Project_
and effort by both developer
management_software
and user
Book:-
10.Conclusion
1. Pressman , software engineering A
practitioner’s approach

2. An integrated approach to software

engineering , 3rd edition by Pankaj
Jalote