Scribd
Upload
21 views2 pages

Software Development Lifecycle Overview

The document discusses software engineering and the software development life cycle. It describes two common models for the software development process: 1) The waterfall model, where each phase (analysis, design, implementation, testing) must be completed before moving to the next phase in a linear fashion. This allows each group to know what to work on but makes it difficult to locate problems. 2) The incremental model, where an initial simplified version is developed and tested, then more details and functionality are incrementally added and tested at each step to more quickly find and address problems.

Uploaded by

Kayla-Irma Neethling
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
21 views2 pages

Software Development Lifecycle Overview

The document discusses software engineering and the software development life cycle. It describes two common models for the software development process: 1) The waterfall model, where each phase (analysis, design, implementation, testing) must be completed before moving to the next phase in a linear fashion. This allows each group to know what to work on but makes it difficult to locate problems. 2) The incremental model, where an initial simplified version is developed and tested, then more details and functionality are incrementally added and tested at each step to more quickly find and address problems.

Uploaded by

Kayla-Irma Neethling
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Software Engineering

Sources: Forouzan, B. Foundations of Computer Science, 3rd edition

1. The software Life Cycle


A fundamental concept in software engineering is the software lifecycle . Software, like many other products,
goes through a cycle of repeating phases (Figure 10.1).

Figure 10.1 The software lifecycle

Software is first developed by a group of developers. Usually it is in use for a while before modifications are
necessary. Modification is often needed due to errors found in the software, changes in the rules or laws
governing its design, or changes in the company itself. The software therefore needs to be modified before
further use. These two steps, use and modify, continue until the software becomes obsolete. By ‘obsolete’, we
mean that the software loses its validity because of inefficiency, obsolescence of the language, major changes in
user requirements, or other factors.

1.1. Development Process Models


Although software engineering involves all three processes in Figure 10.1, in this chapter we discuss only
the development process , which is shown outside the cycle in Figure 10.1. The development process in the
software lifecycle involves four phases: analysis, design, implementation, and testing. There are several models
for the development process. We discuss the two most common here: the waterfall model and the incremental
model.

 Analysis - The development process starts with the analysis phase. This phase results in a specification
document that shows what the software will do without specifying how it will be done.
 Design - The design phase defines how the system will accomplish what was defined in the analysis
phase. In the design phase, all components of the system are defined.
 Implementation - In this phase the programmers write the code.
 Testing - The goal of the testing phase is to find errors, which means that a good testing strategy is the
one that finds most errors.

Integration and maintenance are also tasks to be performed in software engineering, in particular when
delivering or deploying software, although it might not be seen as part of the development process itself.
Also note that it is more often than not the practice to perform verification and testing throughout the
development life cycle.

1.1.1. The Waterfall Model


One very popular model for the software development process is known as the waterfall model (Figure
10.2). In this model, the development process flows in only one direction. This means that a phase cannot be
started until the previous phase is completed.
Figure 10.2 The waterfall model

For example, the analysis phase of the whole project should be completed before its design phase is started.
The entire design phase should be finished before the implementation phase can be started.

There are advantages and disadvantages to the waterfall model. One advantage is that each phase is
completed before the next phase starts. The group that works on the design phase, for example, knows
exactly what to do because they have the complete results of the analysis phase. The testing phase can test
the whole system because the entire system under development is ready. However, a disadvantage of the
waterfall model is the difficulty in locating a problem: if there is a problem in part of the process, the entire
process must be checked.

1.1.2. The Incremental Model


In the incremental model, software is developed in a series of steps. The developers first complete a
simplified version of the whole system. This version represents the entire system but does not include the
details. Figure 10.3 shows the incremental model concept.

In the second version, more details are added, while some are left unfinished, and the system is tested
again. If there is a problem, the developers know that the problem is with the new functionality. They do not
add more functionality until the existing system works properly. This process continues until all required
functionality has been added.

Figure 10.3 The incremental model

Common questions

Powered by AI

The traditional software lifecycle can be inefficient in accommodating changes to user requirements or rules since changes occurring after initial phases in models like the waterfall can necessitate revisiting and reworking earlier stages . In flexible models like the incremental model, iterative updates and gradual completion of system functionality allow for more responsive adjustments to evolving user requirements or regulations, thus providing better adaptability and efficiency in handling such changes .

The waterfall model is a linear and sequential approach where each development phase must be completed before the next begins, allowing no overlap or iteration . In this model, the testing phase begins only after all other phases are complete . In contrast, the incremental model builds the software incrementally, where a simplified version of the system is initially created and then additional features are added in stages until the final system is complete. This approach allows testing and adjusting after each increment, providing flexibility and easier detection of issues with new functionalities .

In the waterfall model, locating a problem can be difficult because the process requires reviewing each completed phase retrospectively if an issue arises due to the sequential nature of the process . Conversely, the incremental model isolates potential problems to the most recent increment of functionality, as testing and verification occur in segments. This allows for more straightforward identification and correction of issues relating specifically to the new changes, thus simplifying the debugging process .

The incremental model might be preferred over the waterfall model because it allows for early implementation and testing of parts of the system, making it easier to identify and fix problems with newly added functionalities . It also supports a more flexible and adaptive development process, which is beneficial for projects where requirements might evolve over time or are not fully understood from the start .

The obsolescence of the programming language can significantly impact the software lifecycle by making maintenance, updates, and integration with modern systems more challenging. It can limit the availability of development resources, increase costs due to the need for specialized skills, and force a premature transition to newer technologies. These factors can compromise the software's efficiency and prolong its lifecycle, leading to increased technical debt and accelerated obsolescence of the software itself .

Having completed results from the analysis phase before commencing the design phase ensures a clear understanding of detailed requirements and objectives, which guides accurate and effective design. This establishes a strong foundation for developers, reduces ambiguity in system requirements, and minimizes the risk of misinterpretation, thereby facilitating a smoother design process and fostering efficient resource utilization .

Verification and testing throughout the development lifecycle help ensure that errors are identified and rectified early in the process, which potentially reduces the cost and effort needed to fix defects compared to catching them post-deployment . Continuous testing facilitates the integration of components and helps maintain software quality, leading to a more reliable and robust final product. It also provides iterative feedback, enabling developers to make informed adjustments and improvements during the development rather than after completion .

User feedback in the incremental model plays a crucial role by providing insights into the software's usability, effectiveness, and alignment with user needs during development. It allows developers to make iterative improvements and adjustments to functionality based on real-world use cases and user experiences. This continuous feedback loop can significantly enhance user satisfaction, ensure the software aligns closely with user expectations, and reduce the risk of costly redesigns after project completion .

The initial simplified version acts as a prototype that helps in visualizing the overall system architecture, guiding the design and planning of further increments. It allows for early detection and resolution of fundamental design issues, fosters stakeholder feedback to refine requirements, and serves as a foundation upon which additional functionality can be successfully developed and integrated in subsequent phases .

Software becomes obsolete when it loses its validity due to inefficiency, obsolescence of the language it was developed in, major changes in user requirements, or other impacting factors . Factors contributing to obsolescence include technological advancements, changes in industry standards, and the inability of the software to meet current needs effectively .

You might also like