Teaching material for a course in
Software Project Management &
Software Engineering – part II
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
• Software lifecycle is a series of processes which are used to
build software products. These are also termed software
lifecycle models. The main software lifecycle models
include waterfall model and many varieties of iterative
models like SCRUM, eXtreme Programming etc. Waterfall
model is the classic model for software development where
each development process follows the preceding process
without the room to go back like a waterfall where water
falls from top and goes down without ever coming back to
the top. Software building starts when requirement
gathering is done. From requirements, a software design is
made. From software design, software construction starts.
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
Benefits in terms of productivity gains of Software engineering
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
Software lifecycle in waterfall model
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
• Contrary to waterfall model, iterative models allow the software
building work to go back so that any part of the software can be
rebuilt using rework.
• Models like SCRUM and eXtreme programming in fact try to
minimize the rework by using iterations. In one iteration, small set
of features of the software product are taken and they are
completely built in a short period of time; say one week. Once it is
reviewed and okayed, next set of features are taken. This way, the
complete software product is built over a long period of time.
• Iterative models differ from each other by the degree to which the
iteration takes place. In SCRUM model, the iteration is complete
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
concurrent engineering in Software lifecycle
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
Work products from software lifecycle stages
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
Quality gates for developing a better software product
Part 2: Software Lifecycle Management
Chapter 9 (Introduction to software lifecycle management)
• Waterfall model poses significant risk in terms of rework which may have
to be done when requirements get changed (which is often). The iterative
models offer attractive benefits in this regard. Most of the software
projects where products are built for newer technology like those for
social media, software for gadgets like mobiles, cameras etc. iterative
models are better suited. Due to increased pace with which technology
gets obsolete and newer technology takes its place, iterative models allow
the project teams to incorporate newer technology (changed
requirements) with ease.
• However waterfall model is still better suited for products where a
massive backbone is needed to build a software product. Software
applications for businesses like Enterprise Resource Planning (ERP),
computer operating systems etc. are such examples. The base design for
these products are indeed massive in size and thus iterative models do
suite to build such products.
Part 2: Software Lifecycle Management
Chapter 10 (Requirement Management)
• Requirement gathering is the process of interacting
with end users and take their requirements. These
requirements are then analyzed and a systematic set of
requirements is built.
• One important aspect about requirement management
is that whenever there is a change in any requirement,
it should be recorded immediately and subsequent
processes of design and construction should be able to
incorporate the changes with minimal rework.
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Software requirement types
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Non functional Software requirement types
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Software requirement levels
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Source of Software requirements
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Software requirements process cycle
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Software requirements change management cycle
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Software requirements validation cycle
Part 2: Software Lifecycle Management
Chapter 10 (requirement management)
Software requirements validation cycle in iterative models
Part 2: Software Lifecycle Management
•
•
•
•
•
Chapter 11 (Software Design management)
Software design is the process where the software architecture is built and refined using the end
user requirements. In the waterfall model, the software product will have a large number of parts
which can be designed separately from each other and later can be joined. If you need to break the
software product design into many parts then you can use either top down approach or bottom up
approach. In top down approach, the software design for the entire product is built first and later
its parts are designed. In bottom up approach, the software product parts are designed first and
later they are joined to create design of the entire product.
With each change request there will be a different version of the software design. Maintaining
these design versions through the development process is very important. You have to make sure
that the right design is used for software construction.
Software design should be robust and should also be able to take change requests without any
problems. When a software product is incrementally built then the later versions of the software
design should be fully compatible with the original software design.
There are many software design techniques available to make appropriate software designs for the
product being built. They include prototyping, structural models, object oriented design, entity
relationship models etc.
Refactoring is a design technique which is used in iterative models. When the design become bulky
after many iterations of development, it starts getting crumbling against new features being added
to the product. In such cases, the design is changed so that new factors of the features being added
are incorporated.
Part 2: Software Lifecycle Management
Chapter 11 (design management)
Characteristics of a good software design
Part 2: Software Lifecycle Management
Chapter 11 (design management)
software design using top to bottom method
Part 2: Software Lifecycle Management
Chapter 11 (design management)
software design using bottom up method
Part 2: Software Lifecycle Management
Chapter 11 (design management)
software design techniques
Part 2: Software Lifecycle Management
Chapter 11 (design management)
Cases when software refactoring (re-design) needed
Part 2: Software Lifecycle Management
•
•
•
•
•
•
Chapter 12 (software construction management)
Software construction must be started with some standards in software coding. Without a proper
standard through various parts of the construction, software defects will be injected. Coding
standard should include factors like variable naming conventions, coding structure patterns,
modularity, reliability, safety, maintainability etc.
Programming language should be carefully selected so that it meets the coding requirements.
code reviews should be done whenever a feature is built. Review should ensure that the quality
norms are met and software defects are eliminated whenever they are encountered.
There are many coding methods available which have evolved over time. They include structural
programming, object oriented programming, pair programming, test driven development etc.
Configuration management for software construction should be done carefully. Branching of code
should be decided carefully so that there not many unnecessary branches of the code should exist
and at the same time the software code for required number of software versions are available.
Testing of the source code should be thoroughly done both at unit level and at integration level.
Part 2: Software Lifecycle Management
Chapter 12 (construction management)
Conversion of software design into software product
Part 2: Software Lifecycle Management
Chapter 12 (construction management)
Required construction characteristics for a good software product
Part 2: Software Lifecycle Management
Chapter 12 (construction management)
Software construction verification cycle
Part 2: Software Lifecycle Management
Chapter 12 (construction management)
Software code reuse techniques
Part 2: Software Lifecycle Management
Chapter 12 (construction management)
When Unit testing required?
Part 2: Software Lifecycle Management
Chapter 12 (construction management)
Quality techniques for construction in iterative model
Part 2: Software Lifecycle Management
Chapter 12 (construction management)
Example of complete workflow of construction with configuration management
Part 2: Software Lifecycle Management
•
•
•
•
Chapter 13 (software testing management)
Traditionally Software testing has been often a neglected area as
managements used to see it as a waste of dollars spent (no
productive output in terms of something produced). However with
strict quality norms required these days for software products,
software testing is one of the important aspects on software
projects.
Software testing involves validating a software product by
comparing expected behavior with the actual behavior when
tested.
Verification of the software code on the other hand involves doing
inspection to verify that the software code written correctly or not.
A separate plan for testing is prepared to ensure that proper testing
is done on the project. The testing plan should include test strategy,
resource planning, budget and schedule.
Part 2: Software Lifecycle Management
Chapter 13 (testing management)
Considerations for software testing effort required
Part 2: Software Lifecycle Management
Chapter 13 (testing management)
Drawback of late software testing in development lifecycle
Part 2: Software Lifecycle Management
Chapter 13 (testing management)
Verification & validation on software projects
Part 2: Software Lifecycle Management
Chapter 13 (testing management)
software testing effort estimation
Part 2: Software Lifecycle Management
Chapter 13 (testing management)
software testing – test case lifecycle
Part 2: Software Lifecycle Management
Chapter 13 (testing management)
software testing – defect lifecycle
Part 2: Software Lifecycle Management
Chapter 13 (software testing management)
• Test automation is a good resource to reduce software testing effort. But
all testing activities can not be automated. Testing activities include test
case writing, test case execution, test case result analysis etc. Test case
writing can be automated for unit testing but for other types of testing
(integration testing, user acceptance testing etc.), automation is difficult
and so manual test case writing is done. The first time a test case is run
should be done manually and so it can not be automated. The only area
open for automation is repeated test case execution. So when same test
cases need to be executed many times then those test cases should be
automated. On what kind of projects, this scenario exists? On iterative
projects, the newer versions of the product (with new functionality added)
need to be tested for both new functionality added as well as the older
functionality. In such cases, the test cases written for older features can be
rerun on newer versions of the product. On such projects, test execution
can be automated.
Part 2: Software Lifecycle Management
Chapter 13 (software testing management)
• Software defect tracking is one area which
needs attention to know which parts of the
software product are failing again and again.
Defect tracking is important because it shows
the testing effort in terms of number of
defects found, defects corrected and still open
defects.
Part 2: Software Lifecycle Management
•
•
•
•
•
Chapter 14 (software release & maintenance)
Software lifecycle ends when the software product is released for
production. Software maintenance in production can be considered
another area separately if it is done independently from software
development cycle. But on modern software development projects, where
iterative models are utilized, software maintenance co-exists with
software development.
The activities during product release include end user training, product
implementation, user manual preparation etc. Last minute product
changes sometimes also take place.
Software product maintenance has its own lifecycle. Periodic maintenance
plans are prepared and defects are removed during those periods using
software patches.
Software maintenance can be of type preventive, corrective, and adaptive.
Maintenance techniques include re-egineering, reverse engineering, and
forward engineering.
Part 2: Software Lifecycle Management
Chapter 14 (release management)
Product release management tasks
Part 2: Software Lifecycle Management
Chapter 14 (release management)
Product release types
Part 2: Software Lifecycle Management
Chapter 14 (release management)
Product implementation tasks
Part 2: Software Lifecycle Management
Chapter 14 (release management)
Product maintenance financial considerations
Part 2: Software Lifecycle Management
Chapter 14 (release management)
Software maintenance process models
Part 2: Software Lifecycle Management
Chapter 14 (release management)
Software maintenance lifecycle
Part 2: Software Lifecycle Management
Chapter 14 (release management)
Software maintenance engineering techniques