Software Project Management

SOFTWARE PROJECT MANAGEMENT (SPM)
STUDY MATERIAL
This document contains the study material for Software Project Management as per
the JNTU
syllabus.
CHAPTER #
CHAPTER PAGE
NUMBER
NO. OF
QUESTIONS
UNIT - I
1 Conventional Software Management 4 3
2 Evolution of Software Economics 13 4
UNIT – II
3 Improving Software Economics 18 10
UNIT – III
4 The Old Way and the New 32 4
5 Life-Cycle Phases 40 3
UNIT – IV
6 Artifacts of the Process 46 10
7 Model-Based Software Architecture 63 6
UNIT – V
8 Workflows of the Process 67 3
9 Checkpoints of the Process 72 4
10 Iterative Process Planning 79 4
UNIT – VI
11 Project Organizations and Responsibilities 89 4
12 Process Automation 97 7
UNIT – VII
13 Project Control and Process Instrumentation 111 6
14 Tailoring the Process 125 9
UNIT – VIII
15 Modern Project Profiles 133 7
16 Next-Generation Software Economics 140 4
17 Modern Process Transitions 146 2
Appendix D CCPDS-R Case Study 150 18
STUDY MATERIAL
III V SEMESTER
MC 5.5.1 SOFTWARE PROJECT MANAGEMENT
TEACHING PLAN
Unit/
Item No.
Topic Book
Reference
No. of
periods
UNIT I
1 Conventional Software Management
1.1 The Waterfall Model 6 – 17 2
1.2 Conventional Software Management Performance 17 – 20 1
2 Evolution of Software Economics
2.1 Software Economics 21 – 26 1
2.2 Pragmatic Software Cost Estimation 26 – 30 2
UNIT II
3 Improving Software Economics
3.1 Reducing Software Product Size 33 – 40 2
3.2 Improving Software Processes 40 – 43 1
3.3 Improving Team Effectiveness 43 – 46 1
3.4 Improving Automation through Software Environments 46 – 48 1
3.5 Achieving Required Quality 48 – 51 1
3.6 Peer Inspections: A Pragmatic View 51 – 54 2
UNIT III
4 The Old Way and the New
4.1 The Principles of Conventional Software Engineering 55 – 63 2
4.2 The Principles of Modern Software Management 63 – 66 2
4.3 Transitioning to an Iterative Process 66 – 68 1
5 Life-Cycle Phases
5.1 Engineering and Production Stages 74 – 76 1
5.2 Inception Phase 76 – 77 1
5.3 Elaboration Phase 77 – 79 1
5.4 Construction Phase 79 – 80 1
5.5 Transition Phase 80 – 82 2
UNIT IV
6 Artifacts of the Process
6.1 The Artifact Sets 84 – 96 3
6.2 Management Artifacts 96 – 103 2
6.3 Engineering Artifacts 103 – 105 2
6.4 Pragmatic Artifacts 105 – 108 1
7 Model-Based Software Architecture
7.1 Architecture: A Management Perspective 110 – 111 1
7.2 Architecture: A Technical Perspective 111 – 116 1
STUDY MATERIAL
UNIT V
8 Workflows of the Process
8.1 Software Process Workflows 118 – 121 1
8.2 Iteration Workflows 121 – 124 1
9 Checkpoints of the Process
9.1 Major Milestones 126 – 132 2
9.2 Minor Milestones 132 – 133 1
9.3 Periodic Status Assessments 133 – 134 1
10 Iterative Process Planning
10.1 Work Breakdown Structures 139 – 146 2
10.2 Planning Guidelines 146 – 149 1
10.3 The Cost and Schedule Estimating Process 149 – 150 1
10.4 The Iteration Planning Process 150 – 153 1
10.5 Pragmatic Planning 153 – 154 1
UNIT VI
11 Project Organizations and Responsibilities
11.1 Line-of-Business Organizations 156 – 158 1
11.2 Project Organizations 158 – 165 2
11.3 Evolution of Organizations 165 – 166 1
12 Process Automation
12.1 Tools: Automation Building Blocks 168 – 172 1
12.2 The Project Environment 172 - 186 2
UNIT VII
13 Project Control and Process Instrumentation
13.1 The Seven Core Metrics 188 – 190 1
13.2 Management Indicators 190 – 196 2
13.3 Quality Indicators 196 – 199 1
13.4 Life-Cycle Expectations 199 – 201 1
13.5 Pragmatic Software Metrics 201 – 202 1
13.6 Metrics Automation 202 – 208 1
14 Tailoring the Process
14.1 Process Discriminants 209 – 218 2
14.2 Example: Small-Scale Project versus Large-Scale
Project
218 – 220 1
UNIT VIII
15 Modern Project Profiles
15.1 Continuous Integration 226 – 227 1
15.2 Early Risk Resolution 227 – 228 1
15.3 Evolutionary Requirements 228 – 229 1
15.4 Teamwork among Stakeholders 229 – 231 1
15.5 Top 10 Software Management Principles 231 – 232 1
15.6 Software Management Best Practices 232 – 236 1
16 Next-Generation Software Economics
16.1 Next-Generation Cost Models 237 – 242 2
16.2 Modern Software Economics 242 – 247 1
17 Modern Process Transitions
17.1 Culture Shifts 248 – 251 1
17.2 Denouement 251 - 254 1
Total 75
PART – I SOFTWARE MANAGEMENT RENAISSANCE Page 4 of 187
Chapter – 1 CONVENTIONAL SOFTWARE MANAGEMENT
Software Crisis:
Flexibility of the software is both a boon and a bane.
Boon: it can be programmed to do anything.
Bane: because of the “anything” factor, it becomes difficult to plan, monitor, and control
software development.
This unpredictability is the basis of what is known as “software crisis”.
A number of analyses were done on the state of the software engineering industry over
the last
decades.
Their findings concluded that the success rate of software projects is very low.
Their other findings can be summarized as:
1. Software development is highly unpredictable.
Only about 10% of projects are delivered successfully within initial budget and schedule
estimates.
2. Rather than the technology advances, it is the management discipline that is
responsible
for the success or failure of the projects.
3. The level of software scrap and rework is indicative of an immature process.
The above three analyses-conclusions, while showing the magnitude of the problem and
the state
of the current software management, prove that there is much room for improvement.
1.1 THE WATERFALL MODEL
The conventional software process is based on the waterfall model.
The waterfall model can be taken as a benchmark of the software development process.
As a retrospective, we shall examine the waterfall model theory to critically analyze how
the
industry ignored much of the theory, but still managed to evolve good and not-so-good
practices,
particularly while using the modern technologies.
1.1.1 IN THEORY
Winston Royce’s paper – Managing the Development of Large Scale Software Systems –
based
on lessons learned while managing large software projects, provides a summary of
conventional
software management philosophy.
Three primary points presented in the above paper are:
1. There are two essential steps common to the development of computer programs –
analysis
and coding.
2. In addition to the above steps several other “overhead” steps are to be introduced.
These steps are: system requirement definition, software requirement definition, program
design, and coding.
These steps help in managing and controlling the intellectual freedom related to software
development [in comparison to physical (development) processes.]
The project-profile and the basic steps in developing a large-scale program are:
3. The basic framework described in waterfall model is risky. It is failure-prone.
The testing phase – taken up towards the end of the development life cycle – provides for
the
first time an opportunity to physically try out the timing, storage, input/output transfers,
etc.
against what is analyzed, theoretically.
If any changes are required in the design, they disrupt the software requirements – based
on
which the design is carried out – to become violated.
Most of these development risks can be eliminated by following five improvements to the
basic
waterfall process.
The proposed five improvements are:
1. Program design comes first. The first improvement is in terms of introducing a
preliminary program design phase between the software requirements generation and the
analysis phases.
This ensures that the software will not fail because of storage, timing, and data flux.
As analysis proceeds in the succeeding phase, the designer should make the analyst aware
of the consequences of the storage, timing, and operational constraints.
If the total resources required are insufficient, or the nascent operational design is wrong,
it will be recognized at the very early stage.
Thereby, the iteration/redoing of the requirements analysis or preliminary design can be
taken up
without adversely affecting the final design, coding, and testing activities.
The steps to be followed for this type of program design are:

a) Begin the design process with program designers – not analysts or programmers.
b) Design, define, and allocate data processing modes – even at the risk of being wrong.
c) Allocate processing functions, design the database, allocate execution time, define
interfaces and processing modes with the operating system, describe input and output
processing, and define preliminary operating procedures.
d) Write an overview document that is understandable, informative, and current so that
every one on the project can gain an elemental understanding of the system.
In the modern parlance this “program design first” is termed as architecture-first
development.
2. Document the design. The amount of documentation required in a software project is
very large – beyond the abilities of the programmers, analysts, or program designers to
attempt on their own.
The reasons for the requirement of so much documentation are:
􀁮 Each designer must communicate with interfacing designers, managers, and customers.
Analysis
Coding
Analysis and coding both
involve creative work that
directly contributes to the
usefulness of the end product.
Waterfall Model Part I: The two basic steps to building a program
System
requirements
Software
requirements
Analysis
Program
design
Coding
Testing
Operations
Waterfall Model Part II: The large-scale system approach
1. Complete program design before analysis and coding begin.
2. Maintain current and complete documentation
3. Do the job twice, if possible.
4. Plan, control, and monitor testing.
5. Involve the customer
Waterfall Model Part III: 5 necessary improvements for this approach to work
􀁯 During early phases documentation is the only design.

􀁰 This volume of documentation will be monetarily rewarded by the support it provides
later to test team, maintenance team, and operations personnel who may not be
computer literate.
The artifacts must be documented in an understandable style to and be available to all
the stakeholders and teams.
If the advanced notations, languages, browsers, tools, and methods are used then
much of the documentation is done along the way and thus, doesn’t require much
concentration.
3. Do it twice. When a program is developed for the first time, the version finally being
delivered to the customer for deployment should be the second version.
This second version should be produced after critical review of design/operations is
carried out.
This can be done with the entire process done in miniature, to a time scale relatively
small with respect to the overall effort.
In the first version, a broad view should be taken where trouble spots in the design can
easily be sensed, and removed using alternative models keeping the straightforward
aspects on backburner as long as possible.
Thus, with this broad view, an error-free set of programs should be arrived at.
This is a concise and simplistic description of architecture-first development, in
which an architecture team is responsible for the initial engineering.
Generalizing this practice to a “do it N times” results in the principle of the modernday
iterative development.
Software development is highly dependent on human judgment.
The first-pass “simulation” allows experimentation by testing some key hypotheses.
This type of testing reduces the scope of the human judgment which, in turn, removes the
over-optimism posed in the design due to the human judgment.
This is the description of the spirit of iterative development and its inherent
advantages for risk management.
4. Plan, control, and monitor testing. Test phase uses the maximum resources of
manpower, computer time, and management judgment.
This phase has the greatest risk of cost and schedule, also.
Testing being a phase taken up almost towards the end of the development cycle, there
may not be many alternatives.
If there are any problems still remain uncovered and unsolved beyond the above three
recommendations, it is in the test phase that some important things can be done, and they
include:
􀁮Employ a team of specialists who are not responsible for the original design.
􀁯Employ visual/manual inspections to spot the obvious errors like dropped minus signs,
missing factors of two, jumps to wrong addresses, etc.
􀁰Test every logic path.
􀁱Employ the final checkout on the target computer.
In the modern process, testing is a life-cycle activity requiring fewer total resources and
uncovers issues far earlier than in the life cycle, when backup alternatives will still be
available.
5. Involve the customer. At the design state, the question of what a software does is
subject
to wide interpretation [, despite a prior agreement between the customer and the
designer.]
By involving a customer in a formal way, (s)he can be committed at earlier points before
final delivery.
At three other points of time/development cycle, after the requirements definition stage,
the
customer’s commitment improves the insight, judgment, and commitment in the
development
effort.
These three points are:
􀁮A preliminary software review – following the preliminary program design step
􀁯A sequence of critical software design reviews – during program design
􀁰A final software acceptance review – following testing
This has been a regular practice in the industry with positive results.
Involving the customer with early demonstrations and planned alpha/beta releases is a
proven, valuable technique.
The above discussion on the issues raised in the “paper”, only goes on to prove only
minor flaws
in the theory – even when applied in the context of today’s technology.
The criticism should be targeted at the practice of the approach, which incorporated
various
unsound and unworkable elements.
Past and current practice of the waterfall model approach is referred to as the
“conventional”
software management approach or process.
The waterfall process is no longer a good framework for modern software engineering
practices
and technologies.
It can be used as the reality benchmark to rationalize a process which is improved and
devoid of
the fundamental flaws of the conventional process.
1.1.2 IN PRACTICE
􀂙 Projects using the conventional process exhibited the following symptoms
characterizing their failure:
􀀅Protracted integration and late design breakage
􀀅Late risk resolution
􀀅Requirements-driven functional decomposition
􀀅Adversarial stakeholder relationships
􀀅Focus on documents and review meetings
Protracted Integration and Late Design Breakage
Figure 1-2 illustrates development progress versus time for a typical development project
using
the waterfall model management process.
Progress is defined as percent coded – that is demonstratable in its target form.
Software that is compilable and executable need not necessarily be complete, compliant,
or up to
specifications.
From the figure we can notice, regarding the development activities, that:
Early success via paper designs and thorough briefings
Commitment to code late in the life cycle
Integration difficulties due to unforeseen implementation issues and interface ambiguities
Heavy budget and schedule pressure to get the system working
Late and last-minute efforts of non-optimal fixes, with no time for redesign
A very fragile, unmaintainable product delivered late
Given the immature languages and technologies used in the conventional approach,
􀂙 there was substantial emphasis on perfecting the design before committing it to coding
􀂙 and consequently, it was difficult to understand or make any changes to it.
This practice resulted in the use of multiple formats –
􀂃 requirements in English
􀂃 preliminary design in flowcharts
􀂃 detailed design in program design languages
􀂃 implementations in the target languages like FORTRAN, COBOL, or C
and error-prone, labor-intensive translations between formats.
Conventional techniques imposed a waterfall model on the design process.
This resulted in late integration and lower performance levels.
In this scenario, the entire system was designed on paper, then implemented all at once,
then
integrated.
Only at the end of this process there was scope for system testing to verify the soundness
of the
fundamental architecture – interfaces and structure.
Generally, in conventional processes 40% or more of life-cycle resources are consumed
by
testing.
Table 1-1. Expenditures by activity for a conventional software project

ACTIVITY COST
Management 5%
Requirements 5%
Design 10%
Code and unit testing 30%
Integration and test 40%
Deployment 5%
Environment 5%
Total 100%
Late Risk Resolution
Lack of early risk resolution is another serious issue related with the waterfall process.
This was due to the focus on early paper artifacts in which the real design,
implementation, and
integration risks were relatively intangible.
The risk profile of waterfall model projects includes four distinct periods of risk
exposure, where
risk is defined as the probability of missing a cost, schedule, feature, or quality goal.
Early in the life cycle – as the requirements are being specified – the actual risk exposure
is
highly unpredictable.
After a design concept is available – even on paper – the risk exposure stabilizes.
It usually stabilizes at a relatively higher level as there are too few tangible facts as part
of an
objective assessment.
As the system is coded, some of the individual component risks get resolved.
As the integration begins, the real system-level quantities and risks become tangible.
During this period many real design issues are resolved and engineering trade-offs are
made.
Resolving these issues late in the life cycle, when there is great inertia inhibiting changes,
is very
expensive.
Late design
breakage
Integration
begins
100%
Development Progress
(% Coded)
Project Schedule
Sequential activities: requirements – design – coding – integration – testing
Ad hoc text Flowcharts Source code Configuration
baseline
Requirements
analysis
Program
design
Coding and
unit testing
Format
Activity
Product Documents Documents Coded units Fragile
baselines
Protracted
integration and
testing
Figure 1-2. Progress profile of a conventional software project
Consequently, projects tend to have a protracted integration phase (Fig 1-2) as major
redesign
initiatives are implemented.
This process tends to resolve the important risks, but by sacrificing the quality and its
maintainability.
Redesigning may also include tying loose-ends at the last minute and patching up bits and
pieces
into a coherent single piece.
These sorts of changes do not conserve the overall design integrity and its
maintainability.
Requirements–Driven Functional Decomposition
Traditionally, the software development process has been requirements-driven:
􀁣An attempt is made to provide a precise requirements definition, and
􀁤then to implement exactly those requirements.
This approach depends on specifying requirements completely and unambiguously before
other
development activities can begin.
It naively treats all requirements as equally important, and depends on those requirements
remaining constant over the software development life cycle.
These conditions rarely occur in real world.
Specification of requirements is a difficult and important part of the software
development
process.
Virtually every major software program suffers from severe difficulties in requirements
specification.
The treatment of all requirements as equal wastes away substantial engineering-hours on
lessimportant
requirements from the driving requirements and wastes effort on paperwork associated
with traceability, testability, logistics support, and so on.
This paperwork anyway will be discarded later as the more important requirements and
subsequent understanding evolve.
Another property of the conventional approach is that the requirements are typically
specified in
a functional manner.
The classic waterfall process is built upon the fundamental assumption that the software
itself is
decomposed into functions.
Requirements are then allocated to the resulting components.
This decomposition is different from a decomposition based on OOD and the use of
existing
components.
The functional decomposition precludes an architecture-driven approach as it is built
around
contracts, sub-contracts, and work breakdown structures.
Adversarial Stakeholder Relationships
The conventional process results in adversarial stakeholder relationships because of
􀁮the difficulties of requirements specification, and
High
Low
Project Risk Exposure
Risk
Exploration
Period
Risk Elaboration
Period
Focused
Risk
Resolution
Period
Controlled
Risk
Management
Period
Project Life Cycle
Figure 1-3. Risk Profile of a conventional software project across its life cycle
Requirements Design - Coding Integration Testing
􀁯the exchange of information solely through paper documents that has information in ad
hoc
formats.
The lack of an uniform and standard notation resulted in subjective reviews and
opinionated
exchanges of information.
Typical sequence of events for most of contractual software efforts:
1. The contractor prepared a draft contract-deliverable document capturing an
intermediate
artifact and delivered it to the customer for approval.
2. The customer was expected to provide comments within 2 to 4 weeks.
3. The contractor incorporated these comments and submitted – in 2 to 4 weeks – a final
version for approval.
This type of one-time review process encouraged high-levels of sensitivity on the part of
customers and contractors.
The overhead of such a paper exchange review process was intolerable.
This resulted in mistrust between the customer-contractor.
It made balancing among requirements, schedule, and cost a difficult proposition.
Focus on Documents and Review Meetings
The conventional process focused more on producing documents in an attempt to
describe the
software product, than focusing on producing tangible increments of the products
themselves.
Even milestones are also discussed in meetings in terms of documents only.
For the contractors the major job is of producing documentary evidence of meeting
milestones
and demonstrating progress to stakeholders, instead of spending their energy on reducing
risk
and producing quality software.
Most design reviews resulted in low engineering value and high cost in terms of the effort
and
schedule involved in their preparation and conduct.
T
ABLE 1-2 Results of conventional software project design reviews
APPARENT RESULTS REAL RESULTS
Only a small percentage of audience understands
the software.
Big briefing to a diverse audience Briefings and documents expose few of the
important assets and risks of complex software
systems
There is no tangible evidence of compliance.
A design that appears to be compliant Compliance with ambiguous requirements is of
little value.
Coverage of requirements (typically Few (tens) are design drivers
hundreds) Dealing with all requirements dilutes the focus
on the critical drivers
A design considered “innocent until The design is always guilty.
proven guilty” Design flaws are exposed later in the life cycle.
Diagnosing these five symptoms of:
􀀅Protracted integration and late design breakage
􀀅Late risk resolution
􀀅Requirements-driven functional decomposition
􀀅Adversarial stakeholder relationships
􀀅Focus on documents and review meetings
can be difficult, particularly in the early phases of the life cycle as by then the problems
with the
conventional model would be cured.
Modern software, hence, should use mechanisms that assess project status early in the
life-cycle
and continue with objective, periodic checkups.
1.2 CONVENTIONAL SOFTWARE MANAGEMENT PERFORMANCE
Barry Boehm’s “Industrial Software Metrics Top 10 List” is a good, objective
characterization of
the state of software development.
Many of the metrics are gross generalizations, yet they accurately describe some of the
fundamental economic relationships that resulted from the conventional process practiced
so far
in the past.
The following are the metrics in Boehm’s top 10 list:
1. Finding and fixing a software problem after delivery costs 100 times more than finding
and fixing the problem in early design phases.
This metric applies equally well for every dimension of process improvement.
It equally well applies to any other process as for software development.
2. You can compress software development schedules 25% of nominal, but no more.
One reason for this is: an N% reduction in schedule requires an M% (M > N) increase in
human resources.
This entails additional management overhead.
Generally, the limit of flexibility in this overhead by scheduling concurrent activities,
conserving sequential activities, and other resource constraints, is about 25%.
For example, say optimally, a 100-staff-month effort may be achievable in 10 months by
10 people.
Could the job be done in one month with 100 people?
Two months with 50 people?
These alternatives are unrealistic.
The 25% compression metric says the limit here is 7.5 months – requiring additional
staff-months to the tune of 20.
Any further schedule compression is doomed to fail.
An optimal schedule could be extended arbitrarily and depending on the staff, could be
performed in a much longer time with fewer human resources.
3. For every $1 spent on development, $2 is spent on maintenance.
Boehm calls this the “iron law of software development.”
Whether it is a long-lived commercial product requiring half-yearly upgrades, or a
custom software system, twice as much money will be spent over the maintenance
lifecycle
than was spent in the development life-cycle.
4. Software development and maintenance costs are primarily a function of the number
of
source lines of code (SLOC).
This metric is more applicable to custom software development in the absence of
commercial components, and lack of reuse as was the case in the conventional era.
5. Variations among people account for the biggest differences in software productivity.
This is a key piece of conventional wisdom:
Hire good people.
When objective knowledge of the reasons for success or failure is not available, the
obvious scapegoat is the quality of the people.
This judgment is subjective and difficult to challenge.
6. The overall ratio of software to hardware costs is still growing. In 1955 it was 15:85,
in
1985, 85:15
85% is about the level of functionality allocated to software in system solutions, and not
just about software productivity.
7. Only 15% of software development effort is devoted to programming.
This is an indicator of the need for balance among other activities besides coding like
requirements management, design, testing, planning, project control, change
management,
and tool preparation and selection.
8. Software systems and products typically cost 3 times as much per SLOC as individual
software programs. Software-system products – system of systems – cost 9 times as
much.
This exponential relationship is the essence of what is called diseconomy of scale.
Unlike other commodities, as more software is built it will more expensive per SLOC.
9. Walkthroughs catch 60% of errors.
Reading this with metric-1, walkthroughs – though they catch 60% of errors – are not
catching the errors that matter and certainly not early enough in the life-cycle.
All defects are not created equal.
Human inspection methods like walkthroughs are good at catching surface problems and
style issues.
When ad hoc notations are used, human methods may be useful as a quality assurance
method.
For uncovering issues like resource contention, performance bottlenecks, control
conflicts, and other higher order issues, human methods are not efficient.
10. 80% of the contribution comes from 20% of the contributors.

This is called the ‘Pareto principle’.
This is true about any engineering discipline.
This metric can be expanded into a more specific interpretation for software.
80% of the engineering is consumed by 20% of the requirements.
80% of the software cost is consumed by 20% of the components.
80% of the errors are caused by 20% of the components.
80% of the software scrap and rework is caused by 20% of the errors.
80% of the resources are consumed by 20% of the components.
80% of the engineering is accomplished by 20% of the tools.
80% of the progress is made by 20% of the people.
These relationships provide good benchmarks for evaluating process improvements and
technology improvements.
They represent rough rules of thumb to characterize the performance of the conventional
software management process and technologies, objectively.
Questions on this chapter:
1. Describe the five possible improvements to the waterfall model.
2. List out the symptoms of ill-managed software processes using the conventional
models.
3. Explain Boehm’s Industrial Software Metrics Top 10 List.
Difficult words:
Scrap waste/refuse amass collect over time
embryonic early in life-cycle deploy install
Concise brief and clear shoe-horn removing roughness
Fragile delicate adversarial with opposition
Façade deceptive face

Chapter – 2 EVOLUTION OF SOFTWARE ECONOMICS
Software engineering is dominated by intellectual activities focused on solving problems
of high complexity with numerous unknowns in competing points of view.
􀁮The early software approaches in 1960s and 1970s can be described as craftsmanship,
with each project using a custom process and custom tools.
􀁯In the 1980s and 1990s, the software industry matured and transitioned to more an
engineering discipline.
Most software projects in this era were primarily research-intensive, dominated by
human creativity and diseconomies of scale.
􀁰The current generation of software processes is driving toward a more
productionintensive
approach dominated by automation and economies of scale.
2.1 SOFTWARE ECONOMICS
Software cost models can be abstracted into a function of five basic parameters:
① Size
② Process
③ Personnel
④ Environment
⑤ Required quality
① The size of the end product – in human-generated components – quantified in terms
of the number of source instructions or the number of function points required
developing the required functionality.
② The process used to produce the end product, in particular the ability of the process to
avoid non-value-adding activities (rework, bureaucratic delays, and communications
overhead).
③ The capabilities of software engineering personnel and particularly their experience
with the computer science issues and the applications domain issues of the project.
④ The environment, which is made up of the tools and techniques available to support
efficient software development and to automate the process.
⑤ The required quality of the product, including its features, performance, reliability,
and adaptability.
The relationships among these parameters and the estimated cost can be written as:
Effort = (Personnel) (Environment) (Quality) (Size Process)
This is an abstracted form of all parametric models for estimating software costs.
The relationship between effort and size exhibits a diseconomy of scale in most of the
current software cost models.
This diseconomy of scale is a result of the process exponent being greater than 1.0.
Contrary to general manufacturing processes, the more software is built, the more
expensive it is per unit item.
For example, for a given application, a 10,000-line software solution will cost less per
line than 1,00,000-line software solution.
How much less?
Assume that the 1,00,000-line system requires 900 staff-months for development, or
about 111 lines per staff-month, or 1.37 hours per line. And
for the 10,000-line software system the estimate would be: 62 staff-months, or about 175
lines per staff-month, or 0.87 hour per line.
The pre-line cost for the smaller application is less than for the larger application.
The reason: the complexity of managing interpersonal communications as the number of
team members scales up.
Figure 2-1 shows three generations of basic technology advancement in tools,
components, and processes.
Assuming the levels of quality and personnel are constant, the y-axis refers to software
unit costs – like per SLOC, FP, or Component, etc.
The x-axis represents the life cycle of the software development.
The three generations of software development are defined as conventional, transition,
and modern practices.
Technologies for environment automation, size reduction, and process improvement are
not independent of one another.
In each era, the key is complementary growth in all technologies.
For example, the process advances couldn’t be used successfully without new component
technologies and increased tool automation.
The use of modern practices and the promise of improved economics are not always
guaranteed.
Organizations are achieving better economics of scale in successive technology phases.
This is because of the multiplicity of similar projects being very large in size (systems of
systems), and most of them being long-lived products.
Figure 2-2 provides an overview of how a ROI profile can be achieved in subsequent
efforts across life cycles of different domains.
Software
ROI
Target objective: Improved ROI
Cost
Software Size
- 1960s-1970s
- Waterfall model
- Functional design
- Diseconomy of scale
- 1980s-1990s
- Process improvement
- Encapsulation-based
- Diseconomy of scale
- 2000 and on
- Iterative development
- Component-based
- Return on investment
Corresponding environment, size, and process technologies
Conventional Transition Modern Practices
Environments/tools:
Custom
Environments/tools:
Off-the-shelf, separate
Environments/tools:
Off-the-shelf, integrated
Size:
100% custom
Size:
30% component-based
70% Custom
Size:
70% component-based
30% Custom
Process:
Ad hoc
Process:
Repeatable
Process:
Managed/measured
Typical project performance
Predictably bad Unpredictable Predictable
Always: Infrequently: Usually:
On budget
On schedule
On budget
On schedule
Over budget
Over schedule
FIGURE 2-1. Three generations of software economics leading to the target objective

2.2 PRAGMATIC SOFTWARE COST ESTIMATION
A critical problem in software cost estimation is the non-availability of case studies of
projects that used iterative development process.
The existing tools all claim their suitability but can’t quote from empirical studies about
their success.
Further, in the software industry there are no standard or consistent metrics or atoms of
units of measure. So the available data cannot be used for comparison purposes.
It is difficult to collect a homogeneous set of data for the projects in an organization and
it is much more difficult to collect data across organizations with different processes,
languages, domains, and so on.
The fundamental unit of size – SLOC – is counted differently across the industry.
Modern languages like – Ada 95 and JAVA – don’t make a simple definition of a source
line reportable by the compiler.
The exact definition of a FP or a SLOC is not very important, as long as everyone –
importantly – uses the same definition.
Three topics of interest in the debate among developers and vendors in terms of cost
estimation are:
1. Which cost estimation model to use
2. Whether to use SLOC or FP as a measure
3. What constitutes a good estimate
Investment in common architecture,
process, and environment for all lineof-
business systems
First
system
Second
system
Achieving ROI across line of business
Line-of-Business Life Cycle: Successive Systems
Investment in robust architecture,
iterative process, and process
automation
First
iteration
Second
iteration
Achieving ROI across a project with multiple iterations
Line-of-Business Life Cycle: Successive Iterations
Nth iteration
Investment in product architecture, lifecycle
release process, and process
automation
First
release
Second
release
Software
ROI
Achieving ROI across a life cycle of product releases
Line-of-Business Life Cycle: Successive Releases
Nth release
Software
ROI
Software
ROI
FIGURE 2-2. Return on investment in different domain
Nth system

Among all the commercial cost estimation models available COCOMO, Ada COCOMO,
and COCOMO II are the most open and well-documented models.
With reference to the measurement of software size: there are basically two points of
view: SLOC and FP. [The third one – an ad hoc point of view by immature developers
uses no systematic measurement of size.]
Many software experts feel SLOC to be a poor measure of size.
Generally, people are comfortable with “mass” figures like 1,000 lines of code rather
than with a description like 20 function points, 6 classes, 5 use cases, 4 object points, 6
files, 2 subsystems, 1 component, or 6,000 bytes.
Even with a description of the later type, people tend to ask for the corresponding SLOC
quantity.
So SLOC is still relevant both as a measure and also with people.
Today, language advance and the use of components, automatic source code generation,
and OOP have made SLOC a much more ambiguous measure.
The use of function points (FP) has a large following.
The primary advantage of using FP is that it is independent of technology. So it is a better
primitive unit for comparisons among projects and organizations.
A disadvantage with FP is that the primitive definitions are abstract and measurements
are not easily derived directly from the evolving artifacts.
Anyone doing cross-project or cross-organization comparisons should use FP as the
measure of size.
FP is also a more accurate estimate in the early phases of a project life cycle.
In later phases, SLOC becomes a more useful and precise measurement basis of various
metrics perspectives.
The general accuracy of conventional cost models – like COCOMO – is described as
“within 20% of actuals, 70% of the time.”
This level of unpredictability in the conventional software development process is
frightening, as missing schedules/costs is more common in the process.
This is an interesting phenomenon when scheduling labor-intensive efforts.
Unless specific incentives are provided for beating the deadline, projects rarely fare as
planned.
Teams and individuals perform sub-planning to meet “their” objectives.
If the time objective is lenient, they spend their energy elsewhere or go after more-
thanrequired
quality.
People, generally, by nature, do not propose to accelerate a schedule.
Even if some of them propose to accelerate, it will meet with resistance from others who
have to synchronize their activities.
So, plans need to be as ambitious as can possibly be achieved.
Most real-world use of cost models is bottom-up (substantiating a target cost) rather than
top-down (estimating the “should” cost).
Figure 2-3 illustrates the predominant practice.
The predominant practice:
The software project manager defines the target cost of the software, then manipulates the
parameters and sizing until the target cost can be justified.
The rationale for the target cost may be to
􀂃 win a proposal
􀂃 solicit customer funding
􀂃 attain internal corporate funding
􀂃 or to achieve some other goal.

The above practice is absolutely necessary
① to analyze the cost risks, and
② to understand the sensitivities and trade-offs objectively.
It provides scope to the project manager to examine the risks associated with achieving
the target costs, and to discuss this information with other stakeholders.
It results in various combinations in the plans, designs, process, or scope being proposed.
This process provides a platform for a basis of estimate and an overall cost analysis.
Independent cost estimates – done by people independent of the development team – are
generally inaccurate.
A credible estimate can be produced by a competent team – consisting of the software
project manager, and the software architecture, development, and test managers –
iteratively preparing several estimates and sensitivity analyses.
Such a team, ultimately, takes the ownership of that cost estimate for the project to
succeed.
A good software cost estimate will have the following attributes:
It is conceived and supported by the project manager, architecture team, development
team, and test team accountable for performing the work.
It is accepted by all stakeholders as ambitious and realizable.
It is based on a well-defined software cost model with a credible basis.
It is based on a database of relevant project experience that includes similar processes,
similar environments, similar quality requirements, and similar people.
It is defined in enough detail so that its key risk areas are understood and the probability
of success is objectively assessed.
Achieving all the attributes in one estimate is rarely possible.
A good estimate can be achieved in a straightforward manner in later life-cycle phases of
a mature project using a mature process.
1. Describe the evolution of the software economics.
2. Show how in the third generation of software evolution the target object was
achieved?
3. Explain how ROI is achieved across different problem domains over the
generations of software evolution.
4. Explain (a) which cost estimation model to use, (b) which software metric to use
for cost estimation, and (c) attributes of a good cost estimate.
Software manager, software
architecture manager, software
development manager, software
assessment manager
Cost modelers
Cost estimate
Risks, options,
trade-offs,
alternatives
This project must cost
$X to win this business
Here is
how justify
that cost
FIGURE 2-3. The predominant cost estimation process
Chapter – 3 IMPROVING SOFTWARE ECONOMICS
Improvements in the economics of software development are not only difficult to achieve
but also difficult to measure and substantiate.
Focus on improving only one aspect of software development process will not realize any
significant economic improvement even though it improves the one aspect spectacularly.
The key to substantial improvement is a balanced focus across interrelated dimensions.
The important dimensions are structured around the five basic parameters of the software
model:
1.Reducing the size or complexity of the product to be developed
2.Improving the development process
3.Using more-skilled personnel and better teams
4.Using better environments – tools to automate the process
5.Trading off or backing off on quality thresholds
These parameters are given in priority order for most software domains:
TABLE 3-1. Important trends in improving software economics
COST MODEL PARAMETERS TRENDS
Size
Abstraction and component-based
development technologies
Higher order languages (C++, Ada95, Java, VB, etc.)
Object-oriented – analysis, design, programming)
Reuse
Commercial components
Process
Methods and techniques
Iterative development
Process maturity models
Architecture-first development
Acquisition reform
Personnel
People factors
Training and personnel skill development
Teamwork
Win-win cultures
Environment
Automation technologies and tools
Integrated tools (visual modeling, compiler, editor,
debugger, change management, etc.)
Open systems
Hardware platform performance
Automation of coding, documents, testing, analyses
Quality
Performance, reliability, accuracy
Hardware platform performance
Demonstration-based assessment
Statistical quality control
The above table lists some of the technology developments, process improvement efforts,
and management approaches targeted at improving the economics of software
development and integration.
There are significant dependencies among these trends.
Tools enable size reduction and process improvements.
Size reduction approaches lead to process changes.
Process improvements drive tool requirements.
In the domain of user interface software, a decade earlier, development teams had to
spend extensive time analyzing operations, human factors, screen layout, and screen
dynamics – all on paper as committing designs was very expensive.
So it was heavy workload in the initial stages in the form of paper artifacts which had to
be frozen after taking the user concurrence and the high construction costs could be
minimized.
Today, graphical user interface (GUI) technology tools enable a new and different
process.
A matured GUI technology has made the conventional process obsolete.
GUI tools enable the developers to construct an executable user interface faster and at
less cost.
Paper descriptions are no more necessary, resulting in better efficiency.
Operations analysis and human factors analysis – still relevant – are carried out in a
realistic target environment using existing primitives and building blocks.
Engineering and feedback cycles now take only a few days/weeks – a great reduction
from months’ of time required earlier.
Further, the old process could not afford re-runs. Designs were done completely – after
thorough analysis and design – in one construction cycle.
The new GUI process is geared to take the user interface through a few realistic versions,
incorporating user feedback all along the way.
It also achieves a stable understanding of the requirements and the design issues in
balance with one another.
The ever-increasing advances in the hardware technology also have been influencing the
software technology improvements.
The availability of higher CPU speeds, more memory, and more network bandwidth has
eliminated many complexities.
Simpler, brute-force solutions are now possible – all this because of advances in
hardware technology.
3.1 REDUCING SOFTWARE PRODUCT SIZE
Producing a product that achieves design goals with minimum amount of
humangenerated
source material is the most significant way to improve return on investment
(ROI) and affordability.
Component-based development is the way for reducing the “source” language size.
Reuse, OO technology, automatic code generation, and higher-order programming
languages are all focused on achieving a system with fewer lines of human-specified
source directive/statements.
This size reduction is the primary motivation behind improvements in
􀂙 higher order languages – like C++, Ada 95, Java, V Basic, and 4GLs
􀂙 automatic code generators – CASE tools, visual modeling tools, GUI builders
􀂙 reuse of commercial components – OSs, windowing environments, DBMSs,
middleware, networks
􀂙 object-oriented technologies – UML, visual modeling tools, architecture
frameworks.
There is one limitation in this “type” of code/size reduction:
Apparently, this recommendation comes from a simple observation: code that isn’t there
need not be developed and can’t break.
This is not entirely the case.
When size-reducing technologies are used, they reduce the number of human-generated
source lines.
All of them tend to increase the amount of computer-executable code.
So this negates the second part of the observation.
Mature and reliable size reduction technologies are powerful at producing economic
benefits.
Immature technologies may reduce the development size but require more investment in
achieving required levels of quality and performance.
This may have a negative impact on overall project performance.
3.1.1 LANGUAGES
Universal function points (UFPs) are useful metrics for language-independent early
lifecycle
estimates.
UFPs are used to indicate the relative program sizes required to implement a given
functionality.
The basic units of FPs are
external user inputs
external outputs,
internal logical data groups,
external data interfaces, and
external inquiries.
SLOC metrics are useful as estimators after a candidate solution is formulated and an
implementation language is known.
Substantial data is documented relating SLOC to FPs as shown below:
TABLE 3-2. Language expressiveness of some of the popular languages
LANGUAGE SLOC PER UFP
Assembly 320
C 128
FORTRAN 77 105
COBOL 85 91
Ada 83 71
C++ 56
Ada 95 55
Java 55
Visual Basic 35
Visual Basic: useful for building simple interactive applications, not useful for real-time,
embedded programs.
Ada 95: useful for mission critical real-time applications, not useful for parallel,
scientific,
and highly number-crunching applications on higher configurations.
Data such as this – spanning application domains, corporations, and technology
generations – should be interpreted and used with great care.
Two observations within the data concern the differences and relationships between Ada
83 and Ada 95, and C and C++.
The difference in expressiveness between the two versions of Ada is mainly due to the
features added to support OOP.
The difference between the two versions of C is more profound.
C++ incorporated several of the advanced features of Ada with more support for OOP.
C++ was developed as a superset of C.
This has its pros and cons.
The C compatibility made it easy for C programmers to migrate to C++.
On the downside, a number of C++ compiler users were programming in C, so the
expressiveness of the OOP based C++ was not being exploited.
The evolution of Java eliminated many of the problems in the C++ language.
It conserves the OO features and adds further support for portability and distribution.
UFPs can be used to indicate the relative program sizes required to implement a given
functionality.
For example, to achieve a given application with a fixed number of function points, one
of the following program sizes would be required:
􀂾 10,00,000 lines of assembly language
􀂾 4,00,000 lines of C
􀂾 2,20,000 lines of Ada 83
􀂾 1,75,000 lines of Ada 95 or C++
Reduction in the size of human-generated code, in turn reduces the size of the team and
the time needed for development.
Adding a commercial DBMS, a commercial GUI builder, and a commercial middleware
can reduce the effective size of development to the following final size:
75,000 line of Ada 95 or C++ with integration of several commercial components
The use of the highest level language and appropriate commercial components has a
sizable impact on cost – particularly when it comes to large projects which have higher
life-cycle cost.
Generally, simpler is better: reducing size increases understandability, changeability, and
reliability.
􀂃 The data in the table illustrate why modern
languages like C++, Ada 95, Java, and Visual
Basic are more preferred.
􀂃 Their level of expressiveness is attractive.
􀂃 There is risk of misuse in applying the data in
the table.
􀂃 This data is a precise average of several
imprecise numbers.
􀂃 Each language has a domain of usage.
􀂃 The values indicate the relative
expressive power of various languages.
􀂃 Commercial components and code
generators can further reduce the size of
human-generated code.
But, the higher level abstraction technologies tend to degrade performance, increase
resource consumption.
These drawbacks, mostly, can be overcome by hardware performance improvements and
optimization.
These improvements may not be as effective in embedded systems.
3.1.2 OBJECT-ORIENTED METHODS AND VISUAL MODELING
The later part of 1990s has seen a shift towards OO technologies.
Studies have concluded that OO programming languages appear to benefit both software
productivity and software quality, but an economic benefit has yet to be demonstrated.
One reason for the lack of this proof could be the high cost of training in OO design
methods like the UML.
OO technology provides more formalized notations for capturing and visualizing
software abstractions.
This has an impact in reducing the overall size of the product to be developed.
Grady Booch proposed three other reasons for the success of the OO projects. These are
good examples of the interrelationships among the dimensions of improving software
economics:
1.An OO model of the problem and its solution encourages a common vocabulary
between the end users of a system and its developers, thus creating a shared
understanding of the problem being solved.
􀂎 This is an example how the use of OO technology improves teamwork and
interpersonal communications.
2.The use of continuous integration creates opportunities to recognize risk early and
make incremental corrections without destabilizing the entire development effort.
􀂎 This aspect of OO technology enables an architecture-first process in which
integration is an early and continuous life-cycle activity.
3.OO architecture provides a clear separation of concerns among disparate elements of a
system, creating firewalls that prevent a change in one part of the system from rending
the fabric of the entire architecture.
􀂎 This feature is crucial to the supporting languages and environments to implement
OO architectures.
Booch also summarized five characteristics of a successful OO project:
1.A ruthless focus on the development of a system that provides a well understood
collection of essential minimal characteristics.
2.The existence of a culture that is centered on results, encourages communication, and
yet is not afraid to fail.
3.The effective use of OO modeling.
4.The existence of a strong architectural vision.
5.The application of a well-managed iterative and incremental development life cycle.
OO methods, notations, and visual modeling provide strong technology support for the
process framework.
3.1.3 REUSE
Reusing existing components and building reusable components have been natural
software engineering activities along with the improvements in programming languages.
Software design methods implicitly dealt with reuse in order to minimize development
costs while achieving all the other required attributes of performance, feature set, and
quality.
Reuse should be treated as a routine part of achieving a return on investment.
Common architectures, common processes, precedent experience, and common
environments are all instances of reuse.
An obstacle to reuse has been fragmentation of languages, operating systems, notations,
machine architectures, tools and standards.
Microsoft’s success on the PC platform is a counter example, to prove the point of

fragmentation being detrimental.
Reuse basically takes place for economic reasons.
So the amount of money made/saved would be a good metric for identifying whether a
set of components is truly reusable.
Reuse components offered by organizations lacking in motivation, trustworthiness, and
accountability for quality, support, improvements, and usability are suspect.
Truly reusable components of value are transitioned to commercial products supported by
organization with the following characteristics:
1.They have an economic motivation for continued support.
2. They take ownership of improving product quality, adding new features, and
transitioning to new technologies.
3.They have a sufficiently broad customer base to be profitable.
The cost of developing a reusable component is not trivial.
Figure 3-1 examines the economic trade-offs.
The steep initial curve shows the economic difficulty to developing reusable components.
Unless the objective is to support reuse across many projects, a convincing business case
cannot be made.
Organizations have to make it mainline business of selling reusable components, for it to
be a fit business case.
To succeed in marketing commercial components, an organization needs three enduring
elements: a development group, a support infrastructure, and a product-oriented sales and
marketing infrastructure.
The complexity and cost of developing reusable components should not be
underestimated.
Reuse is an important discipline that has an impact on the efficiency of all workflows and
the quality of most artifacts.
3.1.4 COMMERCIAL COMPONENTS
Nowadays the approach being pursued is to maximize integration of commercial
components and off-the-shelf products.
The use of commercial components is desirable for reducing custom development. But it
is not a straightforward practice.
Table 3-3 lists some of the advantages and disadvantages of using commercial
components.
The trade-offs are particularly acute in mission-critical domains.
1 project solution: $N and M months
2 project solution: 50% more cost and 100% more time
Many project solution: operating with
high value per unit investment, typical
of commercial products
Development Cost and
Schedule Resources
Number of Projects Using Reusable Components
5 project solution: 125% more cost and
150% more time
FIGURE 3-1. Cost and schedule investments necessary to achieve reusable components
Since the trade-offs have global effects on quality, cost, and supportability, the selection
of commercial components over development of custom components has significant
impact on a project’s overall architecture.
TABLE 3-3. Advantages and disadvantages of commercial components versus custom
software
APPROACH ADVANTAGES DISADVANTAGES
Commercial
components
☺ Predictable license costs
☺ Broadly used mature technology
☺ Available now
☺ Dedicated support organization
☺ Hardware/software
independence
☺ Rich in functionality
􀀯 Frequent upgrades
􀀯 Up-front license fees
􀀯 Recurring maintenance fees
􀀯 Dependency on vendor
􀀯 Run-time efficiency sacrifices
􀀯 Functionality constraints
􀀯 Integration not always trivial
􀀯 No control over upgrades
and maintenance
􀀯 Unnecessary features that
consume extra resources
􀀯 Often inadequate
reliability and stability
􀀯 Multiple-vendor
incompatibilities
Custom
development
☺ Complete change freedom
☺ Smaller, and often simpler
implementations
☺ Often better performance
☺ Control of development and
enhancement
􀀯 Expensive unpredictable
development
􀀯 Unpredictable availability
date
􀀯 Undefined maintenance model
􀀯 Immature and fragile
􀀯 Single-platform dependency
􀀯 Drain on expert resources
The paramount message here is: these decisions must be made early in the life cycle as
part of the architectural design.
3.2 IMPROVING SOFTWARE PROCESSES
Process is an overloaded term.
For software-oriented organizations there are many processes and sub-processes.
The main and distinct process perspectives are:
Metaprocess: an organization’s policies, procedures, and practices for pursuing a
software-intensive line of business.
The focus of this process is on organizational economics, long-term
strategies, and a software ROI.
Macroprocess: a project’s policies, procedures, and practices for producing a complete
software product within certain cost, schedule, and quality constraints.
The focus of the macroprocess is on creating an adequate instance of the
metaprocess for a specific set of constraints.
Microprocess: a project team’s policies, procedures, and practices for achieving an
artifact of the software process.
The focus of the microprocess is on achieving an intermediate product
baseline with adequate quality and adequate functionality as economically
and rapidly as possible.
Although these three levels of process overlap somewhat, they have different objectives,
audiences, metrics, concerns, and time scales.
These are shown in Table 3-4.
TABLE 3-4. Three levels of process and their attributes
ATTRIBUTES METAPROCESS MACROPROCESS MICROPROCESS
Subject Line of business Project Iteration
Objectives 􀂃 Line-of-business
profitability
􀂃 Competitiveness
􀃠 Project profitability
􀃠 Risk management
􀃠 Project budget,
schedule, quality
􀂌 Resource management
􀂌 Risk resolution
􀂌 Milestone budget,
schedule, quality
Audience 􀂃 Acquisition
authorities, customers
􀂃 Organizational
management
􀃠 Software project
managers
􀃠 Software engineers
􀂌 Sub-project managers
􀂌 Software engineers
Metrics 􀂃 Project predictability
􀂃 Revenue, market share
􀃠 On budget, on
schedule
􀃠 Major milestone
success
􀂌 On budget, on
schedule
􀂌 Major milestone
progress
􀃠 Project scrap and

rework
􀂌 Release/iteration scrap
and rework
Concerns 􀂃 Bureaucracy Vs
standardization
􀃠 Quality Vs financial
performance
􀂌 Content Vs schedule
Time scales 􀂃 6 to 12 months 􀃠 1 to many years 􀂌 1 to 6 months
􀀅The macroprocess is the project-level process that affects the cost estimation
model.
􀀅All project processes consist of productive activities and overhead activities.
􀀅For a project to be successful a complex web of sequential and parallel steps are
required.
􀀅As the scale of project increases the complexity of the web also increases.
􀀅To manage the complexity of the web, overhead steps also have to be included.
􀀅Productive activities result in tangible progress toward the end-product.
􀂙 In a software project the productive activities include: prototyping, modeling,
coding, debugging, and user-documentation.
􀀵 Overhead activities – that have an intangible effect – are required in plan
preparation, documentation, progress monitoring, risk assessment, financial
assessment, configuration control, quality assessment, integration, testing, late
scrap and rework, management, personnel training, business administration, and
other such tasks.
􀀵 Overhead activities include many value-added efforts.
􀀵 Less effort devoted to these overhead activities implies more effort can be
expended for the productive activities.
􀀵 The objective of process improvement is to maximize the allocation of resources
to productive activities and minimize the impact of overhead on resources such as
personnel, computers, and schedule.
􀀵 Scrap and rework arise at two stages in the life cycle: ones during the regular
development – as a by-product of prototyping efforts. This is a productive
necessity to resolve the unknowns in the solution space.
􀀵 If the scrap and rework – called late – arise, in the second stage, during late lifecycle
it is highly undesirable.
Personnel training can be viewed from two perspectives:
􀂾 One, as an organizational responsibility,
􀂾 Two, as a project responsibility.
Training the people on the project in processes, technologies or tools is going to add to
the project overheads.
When the personnel are already trained for the project, before they are on to the project,
then the project will be immensely benefited in the form of saving of time, and resources.
The quality of the software process strongly affects the required effort and thereby the
schedule for producing the software product.
The difference between a good process and a bad one will affect overall cost estimates by
50% to 100%.
Reduction in effort will improve the overall schedule.
So a better process can have a greater effect in reducing the time it will take for the team
to achieve the product vision with the required quality.
The reasons for this improvement:
Schedule improvement has three dimensions:
1.We could take an N-step process and improve the efficiency of each step.
2.We could take an N-step process and eliminate some steps so that it is now only an
Mstep
process.
3.We could take an N-step process and use more concurrency in the activities being
performed or the resources being applied.
Time-to-market or last-minute improvement strategies emphasize the first dimension.
There is a great potential in focusing on improving the 2nd and the 3rd dimension.
The primary focus of process improvement should be on achieving an adequate solution

in the minimum number of iterations and eliminating as much downstream scrap and
rework as possible.
Every instance of rework introduces a sequential set of task to be redone.
Suppose a team completes the sequential steps of analysis, design, coding, and testing of
a feature, and then uncovers a design flaw in testing.
Now a sequence of redesign, recode, and retest is required.
These task sequences are the primary obstacle to schedule compression.
So, the primary impact of process improvement should be the reduction of scrap and
rework late in the life-cycle phases.
In a perfect software engineering world – with an immaculate problem description, an
obvious solution space, a development team of experienced personnel, adequate
resources, and stakeholders with common goals – a software development process can be
executed in one iteration with negligible scrap and rework.
But we work in an imperfect world and we need to manage engineering activities so that
scrap and rework profiles do not impact the win conditions of any stakeholders.
This is the background for most process improvements.
3.3 IMPROVING TEAM EFFECTIVENESS
Differences in personnel account for the greatest swings in productivity.
The original COCOMO model suggests that the combined effects of personnel skill and
experience can have an impact on productivity of as much as a factor of four.
So there is a difference between a team of amateurs and a team of experts.
In practice, it is risky to assess a given team as being off-scale in either direction.
For a large team it is almost always possible to end up with nominal people and
experience.
Any team with all geniuses with lot of experience, high IQ it may turn to be
dysfunctional.
So instead of “just hire good people”, it should “just formulate a good team.”
Two most important aspects of an excellent team are: balance and coverage.
When a team is out of balance, it is vulnerable.
For example, a football team need for diverse skills. So is it with a software development
team.
Teamwork is more important than the sum of the individuals.
With software teams, a project manager should configure a balance of talent with highly
skilled people in the leverage positions.
Some maxims of team management are:
☺ A well-managed project can succeed with a nominal engineering team.
􀀯 A mismanaged project – even with an expert team – will almost never succeed.
☺ A well-architected system can be built by a nominal team of software builders.
􀀯 A poorly architected system will flounder even with an expert team.
Boehm’s five staffing principles:
1.The principle of top talent: Use better and fewer people.
There is natural team size for most jobs, and being grossly over or under this size is
counter-productive for team dynamics as it results in too little or too much pressure on
individuals to perform.
2.The principle of job matching: Fit the task to the skills and motivation of the people
available.
With software engineers, it is difficult to discriminate the intangible (or immeasurable)

personnel skills and optimal task allocations.
Personal agendas (likes and dislikes) also complicate assignments.
On software teams it is common for talented programmers to seek promotions to
architects and managers.
The skill sets required for architects and managers are quite different.
Most talented programmers are innately unqualified to be architects and managers, and
vice versa.
Yet, individuals and organizations view such promotions as desirable.
Sometimes, it is a loosing proposition either way: promote someone not fully qualified,
it results in a lousy situation; do not promote someone desirous, it results in the person
not performing to capacity.
3. The principle of career progression: An organization does best in the long run by
helping its people to self-actualize.
Good performers usually self-actualize in any environment.
Organizations can help and hinder employee self-actualization.
Organizational energy benefits average and below-average performers the most.
Organizational training programs are strategic with educational value.
Project training is purely tactical, intended to be useful and applied with immediate
effect.
4. The principle of team balance: Select people who will complement and harmonize with
one another.
Software team balance has many dimensions:
Raw skills: intelligence, objectivity, creativity, organization, analytical thinking
Psychological makeup: leaders and followers, risk takers and conservatives, visionaries
and nitpickers, cynics and optimists
Objectives: financial, feature set, quality, timeliness
When a team is unbalanced in any one of the dimensions, a project becomes risky.
Balancing a team is a paramount factor in good team work.
5. The principle of phase-out: Keeping a misfit on the team doesn’t benefit anyone.
A misfit demotivates other team members, will not self-actualize, and disrupts the team
balance in some dimension.
Misfits are obvious, and it is never right to procrastinate weeding them out.
Software development is a team effort.
Managers must nurture a culture of teamwork and results rather than individual
accomplishments.
Of the five principles, team balance and job matching should be the primary objectives.
The top talent and phase out principles are secondary objectives as they are applied
within the context of team balance.
Though career progressions needs to be addressed as an employment practice, individuals
or organizations that stress it over the success of the team will not last long in the
marketplace.
Software project managers need certain leadership qualities to enhance team
effectiveness.
Some of the crucial attributes are:
1.Hiring skills. Placing the right person in the right job is obvious, but is hard to achieve.
2.Customer-interface skill. A prerequisite for success is the avoidance of adversarial
relationships among stakeholders.
3.Decision-making skill. A decisive person only can have a clear sense of direction, and
only such a person can direct others. So indecisiveness is not a characteristic for a
manager to be successful.
4.Team-building skill. Teamwork requires that manager establish trust, motivate
progress,
exploit eccentric skilled persons, transition average people into top performers,
eliminate misfits, and consolidate diverse opinions into a team direction.
5.Selling skill. Successful mangers must sell all stakeholders on decisions and priorities,
sell candidates on job positions, sell changes to the status quo in the face of resistance,
and sell achievements against objectives.
In practice selling requires continuous negotiation, compromise, and empathy.

3.4 IMPROVING AUTOMATION THROUGH SOFTWARE
ENVIRONMENTS
The tools and environment used in the software process have a linear effect on the
productivity of the process.
Planning tools, requirements management tools, visual modeling tools, compilers,
editors,
debuggers, quality assurance analysis tools, test tools, and user interfaces provide support
for automating the evolution of software engineering artifacts.
Configuration management environments provide the foundation for executing and
instrumenting the process.
The isolated impact of tools and automation allows improvements of 20 to 40% in effort.
When tools and environments are viewed as the primary delivery vehicle for process
automation and improvement, their impact can be higher.
Process improvements reduce scrap and rework eliminating steps and minimizing the
number of iterations in the process.
Process improvement also increases the efficiency of certain steps in the process.
This is done – primarily by the environment – by automating manual tasks that are
inefficient or error-prone.
􀀊The transition to a mature software process introduces
􀁮new challenges and opportunities for management control of concurrent activities , and
􀁯for tangible progress and quality assessment.
An environment that provide semantic integration – in which the environment
understands the detailed meaning of the development artifacts, and process automation
can improve productivity, improve software quality, and accelerate the adoption of
modern techniques.
An environment that supports incremental compilation, automated system builds, and
integrated regression testing can provide rapid turnaround for iterative development and
allow development teams to iterate more freely.
An important emphasis of a modern approach is to define the development and
maintenance environment as a first-class artifact of the process.
A robust, integrated development environment must support the automation of the
development process.
This environment should include requirements management, document automation,
host/target programming tools, automated regression testing, continuous and integrated
change management, and feature/defect tracking.
A common thread in successful software projects is they hire good people and provide
them with good tools to accomplish their jobs.
Automation of the design process provides payback in quality, the ability to estimate
costs and schedules, and overall productivity using a smaller team.
Integrated toolsets play an increasingly important role in incremental/iterative
development by allowing the designers to traverse quickly among development artifacts
and keep them up-to-date.
Round-trip engineering is a term used to describe the key capability of environments that
support iterative development.
Different information repositories are maintained for the engineering artifacts.
Automation support is needed to ensure efficient and error-free transition of data from
one artifact to another.
Round-trip engineering describes the environment support needed to change an artifact

freely and have other artifacts automatically changed so that consistency is maintained
among the entire set of requirements, design, implementation, and deployment artifacts.
Forward engineering is the automation of creation of one engineering artifact from
another, more abstract representation.
For example: compilers and linkers provide automated transition of source code into
executable code.
Reverse engineering is the generation or modification of a more abstract representation
from an existing artifact.
Example: creating a visual design model from a source code representation.
With the use of heterogeneous components, platforms, and languages in architectures,
there is an increase in the complexity of building, controlling, and maintaining large-scale
webs of components.
This increased complexity necessitated configuration control and automation of build
management.
The present environments’ support for automation is not to the expected extent.
Example: automated test case construction from use case and scenario descriptions has
not yet evolved to support beyond trivial cases like unit test scenarios.
While describing the economic improvements associated with tools and environments,
tool vendors make relatively accurate individual assessments of life-cycle activities to
support their claims of economic benefits.
For example:
􀂃 Requirements analysis and evolution activities consume 40% of life-cycle costs.
􀂃 Software design activities have an impact on more than 50% of software
development effort and schedule.
􀂃 Coding and unit testing consume about 50% of software development effort and
schedule.
􀂃 Test activities can consume as much as 50% of a project’s resources.
􀂃 Configuration control and change management are critical activities that can
consume as much as 25% of resources of large-scale projects.
􀂃 Documentation activities can consume more than 30% of project engineering
resources.
􀂃 Project management, business administration, and progress assessment can
consume as much as 30% of project budgets.
Taken individually, each of the above claims is correct.
Taken collectively, it takes 275% of budget and schedule resources to complete most
projects!!!!!!!!!!!!!!!!!!!!
Look at a misleading conclusion:
This testing tool improves testing productivity by 20%. Because test activities consume
50% of the life cycle, there will be a 10% net productivity gain to the entire project.
With a $1 million budget, it is affordable to spend $1,00,000 on test tools.
Such simple assertions are not reasonable, given the complex interrelationships among
the software development activities and the tools.
The combined effect of all tools tends to be less than about 40%, and most this benefit
can’t be gained without some change in the process.
So an individual tool can improve a project’s productivity by about 5%.
In general, it is better to normalize claims to the virtual 275% total than the 100% total
we deal with in the real world.
3.5 ACHIEVING REQUIRED QUALITY
The best practices – derived from development process and technologies – improve cost
efficiency and in addition impact improvements in quality for the same cost.
Some dimensions of quality improvement are:

TABLE 3-5. General quality improvements with a modern process
QUALITY DRIVER CONVENTIONAL
PROCESSES
MODERN ITERATIVE
PROCESSES
Requirements
misunderstanding
Discovered late Resolved early
Development risk Unknown until late Understood and resolved early
Commercial components Mostly unavailable Still a quality driver, but trade-offs must
be resolved early in the life-cycle
Change management Late in the life cycle,
chaotic and malignant
Early in the life cycle, straight-forward
and benign
Design errors Discovered late Resolved early
Automation Mostly error-prone,
manual procedures
Mostly automated, error-free evolution
of artifacts
Resource adequacy Unpredictable Predictable
Schedules Over-constrained Tunable to quality, performance, and
technology
Target performance Paper-based analysis
or separate simulation
Executing prototypes, early
performance feedback, quantitative
understanding
Software process rigor Document-based Managed, measured, and tool-supported
Key practices that improve overall software quality include the following:
1.Focusing
􀃖 on driving requirements and critical use cases early in the life cycle
􀃖 on requirements completeness and traceability late in the life cycle
􀃖 throughout the life cycle on a balance between requirements evolution, design
evolution, and plan evolution.
2.Using metrics and indicators to measure the progress and quality of an architecture as it
evolves from a high-level prototype into a fully compliant product.
3.Providing integrated life-cycle environments that support early and continuous
configuration control, change management, rigorous design methods, document
automation, and regression test automation.
4.Using visual modeling and higher level languages that support architectural control,
abstraction, reliable programming, reuse, and self-documentation.
5.Early and continuous insight into performance issues through demonstration-based
evaluations.
When projects incorporate mixtures of commercial components and custom-developed
components, it is important to have an insight into run-time performance issues.
Conventional development processes stressed early sizing and timing estimates of
computer program resource utilization.
The typical chronology of events in performance assessment is:
a) Project inception. The proposed design is asserted to be low risk with adequate
performance margin.
b) Initial design review. Optimistic assessments of adequate design margin are based on
paper analysis or rough simulation of the critical threads.
The actual application algorithms and database sizes are fairly well
understood.
The infrastructure – operating system overhead, database
management overhead, and the interprocess and network
communication overhead – and all the secondary threads are
typically misunderstood.
c) Mid-life-cycle design review. The assessments started whittling away at the margins,
as early benchmarks and initial tests began exposing the optimist
inherent in earlier estimates.
d) Integration and test. Serious performance problems are uncovered, necessitating

fundamental changes in the architecture.
Though the infrastructure was blamed, the real culprit is immature
use of the infrastructure, immature architectural solutions, or
poorly understood early design trade-offs.
This sequence was the result of early performance insight based solely on naïve
engineering judgment of innumerable criteria.
A demonstration-based approach can provide significantly more accurate assessments of
performance issues, particularly in large-scale distributed systems composed of many
interacting components.
Early performance issues are typical and healthy as they expose architectural flaws or
weaknesses in commercial components early in the life cycle when the right trade-offs
can be made.
3.6 PEER INSPECTIONS: A PRAGMATIC VIEW
Peer inspections/reviews are valuable as secondary mechanisms.
Comparatively the following primary quality mechanisms/parameters are more useful
contributors to quality and also they should be emphasized in the management process:
1.Transitioning engineering information from one artifact set to another.
Using this information, and assessing the consistency, feasibility, understandability, and
technology constraints inherent in the engineering artifacts.
2.Major milestone demonstrations to assess the artifacts against tangible criteria in the
context of relevant use cases.
3.Environment tools – compilers, debuggers, analyzers, automated test suites – that
ensure representation rigor, consistency, completeness, and change control.
4.Life-cycle testing for detailed insight into critical trade-offs, acceptance criteria, and
requirements compliance.
5.Change management metric for objective insight into multiple-perspective change
trends and convergence or divergence from quality and progress goals.
In certain cases inspections provide a significant return.
One such value is: in the professional development of a team.
It is generally useful to have the products of the junior team members reviewed by senior
mentors.
This way of exchanging the products of amateurs and the seniors accelerates the
acquisition of knowledge and skill in new personnel.
Gross blunders can be caught and feedback can be properly channeled, thus reducing the
chances of perpetuation of bad practices.
Another value is: holding authors accountable for quality products.
All authors of software and documentation should have their products scrutinized as a
natural by-product of the process.
The coverage of inspection should be across authors rather than across components.
Junior authors can learn while scrutinizing the work of the seniors.
Varying levels of informal inspection are performed continuously when developers read
or integrate software with another author’s software, and during testing by independent
test teams.
This “inspection” is more tangibly focused on integrated and executable aspects of the
system.
Any critical component should be inspected by several stakeholders in its quality,
performance, or feature set.
Inspection focused on resolving an existing issue can help in effectively determining the
cause or finding a resolution for a determined cause.
Many organizations overemphasize meeting and formal inspections, and require coverage
across all engineering products.
This approach can be counterproductive.
Only 20% of technical artifacts – use cases, design models, source code, and test cases –
deserve detailed scrutiny compared with other, more useful quality assurance activities.
A process whose quality assurance emphasis is on inspections will not be cost-effective.
Significant or substantial design errors or architecture issues are rarely obvious unless the
inspection is narrowly focused on a particular issue.
Most inspections are superficial.
When systems are highly complex, with innumerable components, concurrent execution,
distributed resources, and other equally demanding dimensions of complexity, it is very
difficult to comprehend the dynamic interacti9ons within a software system under some
simple use cases.
So, random human inspections tend to degenerate into comments on style and first-order
semantic issues.
They rarely result in the discovery of real performance bottlenecks, serious control issue
like deadlocks, race conditions, or resource contentions, or architectural weakness like
flaws in scalability, reliability, or interoperability.
Architectural issues are exposed only through more rigorous engineering activities like:
􀂾 Analysis, prototyping, or experimentation
􀂾 Constructing design models
􀂾 Committing the current state of the design model to an executable implementation
􀂾 Demonstrating the current implementation strengths and weaknesses in the context
of critical subsets of the sue cases and scenarios
􀂾 Incorporating lessons learned back into the models, use cases, implementations, and
plans
Architectural quality achievement is inherent in an iterative process that evolves the
artifact sets together in balance.
The checkpoints along the way are numerous, including human review and inspections
focused on critical issues.
Focusing a large percentage of a project’s resources on human inspections is bad practice
and only perpetuates the existence of low-value-added box checkers who have no stake in
the project’s success.
Quality assurance is everyone’s responsibility and should be integral to almost all process
activities instead of a separate discipline performed by quality assurance specialists.
1. The key to substantial improvement of software economics is a balanced attack
across several interrelated dimensions. Comment in detail.
2. Explain how reducing software product size contributes to the improvement of
software economics.
3. Explain Booch’s reasons for the success of object-oriented projects. Clearly bring
out the interrelationships among the dimensions of improving software economics.
4. Explain the relative advantages and disadvantages of using commercial
components versus custom software.
5. Explain how software economics is improved by improving software processes.
6. Explain how improvement of team effectiveness contributes to software
economics.
7. Explain Boehm’s staffing principles.
8. Explain how software environments help in improving automation as a way of
improving software economics.
9. Explain the key practices that improve overall software quality, in view of the
general quality improvements with a modern process in comparison with that of
conventional processes.
10. Comment on the relative merits and demerits of peer inspections for quality
assurance.
Difficult words:
caveat caution trivial small/inconsequential
Chapter – 4 THE OLD WAY AND THE NEW
A significant reengineering of the software development process is taking place in the

form of the conventional management and technical practices being replaced by new
approaches combining success themes with advances in software engineering technology.
This transition is motivated by
the insatiable demand for more software features produced more rapidly
under more competitive pressure to reduce cost.
In the commercial software industry, the combination of
􀂾 competitive pressures
􀂾 profitability
􀂾 diversity of customers, and
􀂾 rapidly changing technology
have driven organizations to adopt new management approaches.
Many systems required a new management paradigm to respond to budget pressures, the
dynamic and diverse threat environment, the long operational lifetime of systems, and the
predominance of large-scale, complex applications.
4.1 THE PRINCIPLES OF CONVENTIONAL SOFTWARE
ENGINEERING
After years of software development experience, the software industry formulated a
number of principles.
The following is a description of today’s software engineering principles as a benchmark
for future ideas:
[This description is from Davis’ book that enumerates 201 principles. The top 30
principles are described here.]
1. Make quality #1. Quality must be quantified and mechanisms put into place to
motivate its achievement.
It is not easy to define quality at the outset of the project.
A modern process framework strives to understand the trade-offs among features,
quality, cost, and schedule as early in the life cycle as possible.
This understanding must be achieved to specify or manage the achievement of quality.
2. High-quality software is possible. Techniques that have been demonstrated to
increase quality include involving the customer, prototyping, simplifying design,
conducting inspections, and hiring the best people.
3. Give products to customers early. No matter how hard you try to learn users’ needs
during the requirements phase, the most effective way to determine real needs is to
give users a product and let them play with it.
This is a key tenet of a modern process framework. There must be several
mechanisms to involve the customer throughout the life cycle.
4. Determine the problem before writing the requirements. When faced with what
they believe is a problem, most engineers rush to offer a solution. Before a problem is
tried to be solved, all the alternatives must be explored and one shouldn’t be blinded
by the obvious solution.
The parameters of a problem become more tangible as a solution evolves.
A modern process framework evolves the problem and the solution together until the
problem is fully understood to commit to full production.
5. Evaluate design alternatives. After the requirements are agreed upon, a variety of
architectures and algorithms must be examined. An “architecture” is not simply used
because it was used in the requirements specification.
This principle is based more on the waterfall thinking in two ways:
a) The requirements precede the architecture and don’t evolve together.
b) The architecture is incorporated in the requirement specification.
A modern process promotes the analysis of design alternatives concurrently with
requirements specification.
The notations and artifacts for requirements and architecture are explicitly decoupled.
6. Use an appropriate process model. Each project must select a process that makes
the most sense for that project on the basis of corporate culture, willingness to take
risks, application area, volatility of requirements, and the extent to which
requirements are well understood.
The term process framework should represent a flexible class of processes than a
single rigid instance, as no individual process is universal.
7. Use different languages for different phases. Our industry’s eternal thirst for simple
solutions to complex problems has driven many to declare that the best development
method is one that uses the same notation throughout the life cycle. Why should
software engineers use Ada for requirements, design, and code unless Ada were
optimal for all these phases?
An appropriate organization of languages and notations for the primitive artifacts of
the process should be in place.
8. Minimize intellectual distance. To minimize intellectual distance, the software’s
structure should be as close as possible to real-world structure.
This principle has been the primary motivation for the development of object-oriented
techniques, component-based development, and visual modeling.
9. Put techniques before tools. An undisciplined software engineer with a tool
becomes dangerous, undisciplined software engineer.
This principle is valid in the case of the undisciplined.
In the other cases, it misses two important points:
a) A disciplined software engineer with good tools will out-produce disciplined
software experts with no tools.
b) Automation is one of the best ways to promote, standardize, and deliver good
techniques.
10. Get it right before you make it faster. It is far easier to make a working program
run faster than it is to make a fast program work. Don’t worry about optimization
during initial coding.
Performance and performing (executing) should not be confused with.
This is exemplified in a misstatement like “Early performance problems in a software
system are a sure sign of downstream risk”.
Almost all immature architectures – large-scale ones – have performance issues in
their first executable iterations.
But, having something executing/working early is a prerequisite to understanding the
complex performance trade-offs.
Getting this insight is difficult through analysis.
11. Inspect code. Inspecting the detailed design and code is a much better way to find
errors than testing.
When used judiciously and focused on a known issue, inspections are extremely
effective at resolving problems.
The present hardware resources, programming languages, and automated
environments enable automated analyses and testing to be done efficiently throughout
the life-cycle.
Continuous and automated life-cycle testing is a necessity in the modern iterative
development.
Undirected inspections rarely uncover architectural issues or global design trade-offs.
12. Good management is more important than good technology. The best technology
will not compensate for poor management, and a good manager can produce great
results even with meager resources. Good management motivates people to do their
best, but there are no universal “right” styles of management.
Good management and a team meager in quality are mutually exclusive because a
good manager will attract, configure, and retain a quality team.
13. People are the key to success. Highly skilled people with appropriate experience,
talent, and training are the key. The right people with insufficient tools, languages,
and process will succeed. The wrong people with appropriate tools, languages, and
retain a quality team.
14. Follow with care. Just because everybody is doing something does not make it right
for you. It may be right, but you must carefully assess its applicability to your
environment. Object orientation, measurement, reuse, process improvement, CASE,
prototyping – all these might increase quality, decrease cost, and increase user
satisfaction. The potential of such technique often oversold, and benefits are by no
means guaranteed or universal.
In a rapidly growing industry technology fads are difficult to distinguish from

technology improvements.
Trading off features, costs, and schedules doesn’t always favor the most modern
technologies.
15. Take responsibility. When a bridge collapses we ask, “What did the engineers do
wrong?” Even when software fails, we rarely ask this. The fact is that in any
engineering discipline, the best methods can be used to produce awful designs, and
the most antiquated methods to produce elegant designs.
It takes more than good methods, tools, and components to succeed.
It also takes good people, good management, and a learning culture that is focused on
forward progress even when confronted with numerous and inevitable intermediate
setbacks.
16. Understand the customer’s priorities. It is possible the customer would tolerate
90% of the functionality delivered late if they could have 10% of it on time.
Understanding the customer’s priorities should go only in balance with other
stakeholders’ priorities.
Generally, whenever a customer contracts with a system integrator, the customer need
not always be right, at times the customer could be wrong.
17. The more they see, the more they need. The more functionality or performance you
provide a user, the more functionality or performance the user wants.
The principle is misleading as it may suggest the user should never be shown
anything.
It would be more correct if read as “The more users see, the better they understand.”
Most stakeholder instead of being greedy, understand the limitation of resources and
the constraints of the developers.
Demonstrating intermediate results helps in synchronizing stakeholders’ expectations.
The effect of this principle on a modern process is that the project manager needs to
have objective data ready to ratify the change requests and maintain a balance of
affordability, features, and risk.
18. Plan to throw one away. One of the most important critical success factors is
whether or not a product is entirely new. Such brand-new applications, architectures,
interfaces, or algorithms rarely work the first time.
A plan should be evolve a product from an immature prototype to a mature baseline.
It should not be planned to be thrown away.
A prototype can be thrown away, not from the outset.
This could be a sage advice for 100% custom, leading-edge software following the
older process model.
With the current technology, most of the componentry – the OS, DBMS, GUI,
network, and middleware – exists, and much of what is built in the first pass can be
conserved.
19. Design for change. The architectures, components, and specification techniques you
use must accommodate change.
This is a complex statement to achieve.
It says: predict the future and construct a framework that can accommodate change
that is not yet well defined. To be change-accommodative is critical to success.
Predicting the future exactly is difficult, but attempting to predict the sorts of changes
that are likely in a system’s life cycle is a useful exercise in risk management.
20. Design without documentation is not design. I have often heard software engineers
say, “I have finished the design. All that is left is the documentation.”
This principle was based on the older process of design first, and document later.
With visual modeling and higher programming languages, it is counterproductive to
maintain separate documents for describing the design.
High-level architecture documents are helpful when they are written crisply and
concisely.
Since the primary artifacts used are the design notations, source code, and test
baselines, the principle can be read as “software artifacts should be mostly
selfdocumenting.”
21. Use tool, but be realistic. Software tools make their users more efficient.
This principle trivializes a crucial aspect of modern software engineering: the
importance of the development environment.
A mature process must be well established, automated, and instrumented.
Iterative development projects require extensive automation.
22. Avoid tricks. Many programmers love to create programs with tricks – constructs
that perform a function correctly, but in an obscure way. Show the world how smart
you are by avoiding tricky code.
It is difficult to draw the line between a trick and an innovative solution.
Obfuscated coding techniques should be avoided unless there are compelling reasons
for their use.
23. Encapsulate. Information-hiding is a simple, proven concept that results in software
that is easier to test and much easier to maintain.
Component-based design, OO-design, and modern design and programming notations
have advanced this principle into mainstream practice.
24. Use coupling and cohesion. Coupling and cohesion are the best ways to measure
software’s inherent maintainability and adaptability.
Coupling and cohesion are abstract descriptions of components for which there are no
objective definitions.
Coupling and cohesion, therefore, are difficult to measure.
Modern metrics for maintainability and adaptability are centered on measuring the
amount of software
25. Use the McCabe complexity measure. Although there are many metrics available to
report inherent complexity of software, none is as intuitive and easy to use as Tom
McCabe’s.
Complexity metrics help in identifying the critical components that need special
attention.
It is rare to see these complexity measures being used in field.
They are more of theoretical or academic interest.
They are more useful for automated project management.
26. Don’t test your own software. Software developers should never be the primary
testers of their own software.
An independent test team offers an objective perspective.
On the other hand, software developers need to take ownership of the quality of their
products.
So, developers should test their own software, and so should an independent team.
27. Analyze causes for errors. It is far more cost-effective to reduce the effect of an
error by preventing it than it is to find and fix it. One way to do this is to analyze the
causes of errors as they are detected.
This is a good principle in the construction phase as errors are likely to repeat.
Analyses of errors in complex systems can be over-analysis and over-design on paper
in the early stages of a project.
These activities are more of “error-preventive” efforts.
These activities result in a lower return on investment in comparison with prototyping
and construction activities, which would have made the errors more obvious and
tangible.
This can be restated as (1) don’t be afraid to make errors in the engineering stage and
(2) analyze the cause for errors in the production stage.
28. Realize that software’s entropy increases. Any software system that undergoes
continuous change will grow in complexity and will become more and more
disorganized.
The sign of a poor architecture is that its entropy increases in a way that is difficult to
manage.
Entropy tends to increase dangerously when interfaces are changed for tactical
reasons.
The integrity of an architecture is primarily strategic and inherent in its interfaces.
It must be controlled with intense scrutiny.
Modern change management tools force a project to respect and enforce interface
integrity.
A quality architecture is characterized by minimal increase in entropy and change can
be accommodated with stable, predictable results.
So, an ideal architecture permits change without any abnormal increase in entropy.
29. People and time are not interchangeable. Measuring a project solely by
personmonths
makes little sense.
30. Expect excellence. Your employees will do much better if you have high
expectations for them.
4.2 THE PRINCIPLES OF MODERN SOFTWARE

MANAGEMENT
The current software management principles described, by Davis, evolved from and
improved on conventional techniques.
We have to add some more to emphasize the modern principles.
The top 10 principles are:
1. Base the process on an architecture-first approach.
This requires that a demonstrable balance be achieved among the driving
requirements, the architecturally significant decisions, and the life-cycle plans before
the resources are committe4d for full-scale development.
2. Establish an iterative life-cycle process that confronts risk early.
In sophisticated software systems, it is not possible to define the entire problem,
design the entire solution, build the software, then test the end product in sequence.
Instead, an iterative process that refines the problem understanding, an effective
solution, and an effective plan over several iterations encourages a balanced treatment
of all stakeholder objectives.
Major risks must be addressed early to increase predictability and avoid expensive
downstream scrap and rework.
3. Transition design methods to emphasize component-based development.
To reduce the amount of human-generated source code and custom development, it is
necessary to move to component-based thinking.
A component is a cohesive set of preexisting lines of code, either in source or
executable form, with a defined interface and behavior.
4. Establish a change management environment.
The dynamics of iterative development, including concurrent workflows by different
teams working on shared artifacts, necessitates objectively controlled baselines.
5. Enhance change freedom through tools that support round-trip engineering.
Round trip engineering is the environment support necessary to automate and
synchronize engineering information in different formats like requirements
specifications, design models, source code, executable code, test cases.
Without substantial automation of the bookkeeping, change management,
documentation, and testing, it is difficult to reduce iteration cycles to manageable
time frames in which change is encourages rather than avoided.
Establish an integrated environment is crucial to have change freedom, which is a
necessity in an iterative process.
6. Capture design artifacts in rigorous, model-based notation.
A model-based approach – such as UML – supports the evolution of semantically rich
graphical and textual design notations.
Visual modeling with rigorous notations and a formal machine-processable language
provides for more objective measures than the approach of human review and
inspection of ad hoc design representations in paper documents.
7. Instrument the process for objective quality control and progress assessment.
Life-cycle assessment of the progress and the quality of all intermediate products
must be integrated into the process.
The best assessment mechanisms are well-defined measures derived directly from the
evolving engineering artifacts and integrated into all activities and teams.
8. Use a demonstration-based approach to assess intermediate artifacts.
Transitioning the current state-of-the-product artifacts into an executable
demonstration of relevant scenarios stimulates earlier convergence on integration, a
more tangible understanding of design tradeoffs, and earlier elimination of
architecture defects.
9. Plan intermediate releases in groups of usage scenarios with evolving levels of
detail.
Software management process should aim for early and continuous demonstrations of
the operational aspects of the system, the use cases.
The evolution of project increments and versions/generations should be
commensurate with the understanding of the requirements and architecture.
For organizing requirements, defining iteration content, assessing implementations,
and organizing acceptance testing, usage scenarios are a cohesive tool.
10. Establish a configurable process that is economically scalable.

No single process model is suitable for all software development projects.
A pragmatic process framework must be configurable to a broad spectrum of
applications.
The process must ensure that there is economy of scale and return on investment by
exploiting a common process spirit, extensive process automation, and common
architecture patterns and components.
The following table, Table 4-1, maps the top 10 risks of the conventional process to the
key attributes and principles of a modern process.
Though it contains generalizations, it provides an introduction to the principles of a
modern process.
Waterfall process
Requirements first
Custom development
Change avoidance
Ad hoc tools
Iterative process
Architecture first
Component-based development
Change management
Round-trip engineering
Requirements analysis
Design
Code and unit test
Subsystem integration
System test
Planning and
analysis
Design
ImplemAssessment entation
Architecture first approach The central design element
Design and integration first, then production and test
Iterative life-cycle processes The risk management element
Risk control through ever-increasing function, performance, quality
Component-based development The technology element
Object-oriented methods, rigorous notations, visual modeling
Change management environment The control element
Metrics, trends, process instrumentation
Round trip engineering The automation element
Complementary tools, integrated environments
FIGURE 4-1. The top five principles of a modern process
TABLE 4-1. Modern process approaches for solving conventional problems

CONVENTIONAL
PROCESS: TOP 10 RISKS IMPACT MODERN PROCESS: INHERENT RISK
RESOLUTION FEATURES
1. Late breakage and
excessive scrap/rework
Quality,
cost,
schedule
Architecture-first approach
Automated change management
Risk-confronting process
2. Attrition of key personnel Quality,
cost,
schedule
Successful, early iterations
Trustworthy management and planning
3. Inadequate development
resources
Cost,
schedule
Environments as first-class artifacts of the process
Industrial-strength, integrated environments
Model-based engineering artifacts
4. Adversarial stakeholders Cost,
schedule
Demonstration-based review
Use-case-oriented requirements/testing
5. Necessary technology
insertion
Cost,
schedule
Architecture-first approach
Component-based development
6. Requirements creep Cost,
schedule
Use case modeling
Demonstration-based review
7. Analysis paralysis Schedule Demonstration-based review
Use-case-oriented requirements/testing
8. inadequate performance Quality Demonstration-based performance assessment
Early architecture performance feedback
9. Overemphasis on artifacts Schedule Demonstration-based assessment
Objective quality control
10. inadequate function Quality Iterative development
Early prototypes, incremental releases
4.3 TRANSITION TO AN ITERATIVE PROCESS
In the conventional waterfall model, each stage of the development process is dependent
on completion of the previous stage.
Modern approaches generally require that an initial version of the system be rapidly
constructed early in the development process, with an emphasis on addressing the
highrisk
areas, stabilizing the basic architecture, and refining the driving requirements.
Software development then proceeds as a series of iterations, building on the core
architecture until the desired levels of functionality, performance, and robustness are
achieved.
An iterative process emphasizes the whole system than the individual parts.
Risk is reduced early in the life-cycle through continuous integration and refinement of
requirements, architecture, and plans.
The downstream problems that plagued conventional projects are avoided.
The economic benefits in transitioning from the conventional waterfall model to an
iterative development process are significant, but can’t be quantified.
A benchmark of the expected benefits of process improvement can be obtained from the
process exponent parameters of the COCOMO II model.
These exponent parameters are ⒜ application precedentedness, ⒝ process flexibility,
⒞ architecture risk resolution, ⒟ team cohesion, and ⒠ software process maturity.
Process exponent parameters of the COCOMO II model can be mapped to the ten
principles of a modern process as follows:
(A) Application precedentedness.
Domain experience is a critical factor in understanding ho to plan and execute a
software development project.
For unprecedented systems, a key goal is to confront risks and establish early
precedents, event if they are incomplete or experimental.
This is a benefit in moving to iterative life-cycle process.
Early iterations in the life cycle establish precedents from which the product, the
process, and the plans can be elaborated in evolving levels of detail.
(B) Process flexibility.
Software development is characterized by a broad solution space and a number of
interrelated concerns.
This results in need for continuous incorporation of change(s).
These changes may be inherent in the problem understanding, the solution space, or
the plans.
Project artifacts must be supported by efficient change management in tune with
project needs.
A rigid process and a chaotically changing process are destined to failure.
A configurable process that allows a common framework to be adapted across a
range of projects is necessary to achieve software ROI.
(C) Architecture risk resolution.
Architecture-first development is crucial for a successful development process.
A team develops and stabilizes an architecture before developing all the components.
An architecture-first and component-based development approach forces the
infrastructure, common mechanisms, and control mechanisms to be elaborated early
in the life cycle and drives all component make/buy decisions into the architecture
process.
It initiates integration activity early in the life cycle as the verification activity of
design process and product.
It also enforces the development environment to be configured and exercised early to
ensure early attention to testability and a foundation for demonstration-based
assessment.
(D) Team Cohesion.
Successful teams are cohesive, and cohesive teams are successful.
Successful teams and cohesive teams share common objectives and priorities.
Cohesive teams avoid sources of turbulence and entropy due to difficulties in
synchronizing stakeholder expectations.
Miscommunication – in exchanging information solely through paper documents
containing subjective descriptions – is one of the primary reasons for turbulence.
Advances in technology – programming languages, UML, and visual modeling –
have enabled more rigorous and understandable notations for communicating
engineering information, particularly in the requirements and design artifacts.
[Previously ad hoc paper-based methods were in use.]
These model-based formats have also enabled the round-trip engineering support
needed to establish change freedom.
(E) Software process maturity.
Just as domain experience is crucial for avoiding the application risks and exploiting
the available domain assets and lessons learned, software process maturity is crucial
for avoiding software development risks and exploiting the software assets and lesson
learned.
Truly mature processes are enabled through an integrated environment providing the
appropriate level of automation to instrument the process for objective quality control.
1. List out and explain Davis’ principles of conventional software engineering.
2. List out and explain the principles of modern software management.
3. Explain how modern process approaches can be used for solving conventional
problems.
4. Explain the mapping of process exponent parameters of COCOMO II model to
the top 10 principles of a modern process.
Difficult words:
insatiable unsatisfiable trivial small/inconsequential
meager Scanty/not enough ramification result/consequence
sage Wise trivialize belittle/underestimate
obfuscate disguise/conceal entropy measure of degradation
PART – II A SOFTWARE MANAGEMENT PROCESS FRAMEWORK
CHAPTER – 5 LIFE-CYCLE PHASES Page 40 of 187
For a project to be successful there must be a well defined separation between “research
and development activities” and “production activities”.
A failure to define and execute these two stages with proper balance and appropriate
emphasis leads to the failure of the project.
Most unsuccessful projects exhibit one of the following characteristics:
􀂾 An overemphasis on research and development.
Too many analyses or paper studies are performed.
The construction of engineering baselines is delayed.
􀂾 An overemphasis on production.
Rush-to-judgment designs, premature work by overeager coders, and continuous
hacking are typical.
Successful projects have a well-defined project milestone when there is a transition from
a research attitude to a product attitude.
Earlier phases focus on achieving functionality.
Later phases revolve around achieving a product that can be shipped to a customer, with
explicit attention to robustness, performance, fit, and finish.
This life-cycle balance, subtle and intangible, is the foundation for successful software
management.
A modern software development process must be defined to support the following:
􀀙 Evolution of the plans, requirements, and architecture, together with well-defined
synchronization points.
􀀙 Risk management and objective measures of progress and quality.
􀀙 Evolution of system capabilities through demonstrations of increasing
functionality.
5.1 ENGINEERING AND PRODUCTION STAGES
To achieve economies of scale and higher ROI, a software manufacturing process should
be driven by technological improvements in process automation and component-based
development.
The two stages of the life-cycle at the first order are:
1.Engineering stage, driven by less predictable but smaller teams doing design and
synthesis activities.
2.The production stage, driven by more predictable but larger teams doing construction,
test, and deployment activities.
TABLE 5-1. The two stages of the life cycle: engineering and production
LIFE-CYCLE
ASPECT
ENGINEERING STAGE
EMPHASIS
PRODUCTION STAGE
EMPHASIS
Risk reduction Schedule, technical feasibility Cost
Products Architecture baseline Product release baselines
Activities Analysis, design, planning Implementation, resting
Assessment Demonstration, inspection, analysis Testing
Economics Resolving diseconomies of scale Exploiting economies of scale
Management Planning Operations
The table 5-1 is a summary of the differences in emphasis between the two stages –
engineering and production.
The transition between engineering and production is very crucial for the stakeholders.
Depending on the specifics of a project the time and resources dedicated to the two stages
can be highly variable.
Having only two stages to a life cycle sounds a little coarse, too simplistic, for most
applications.
So, the engineering stage is decomposed into two distinct phases, inception and
elaboration, and the production stage into construction and transition.
These four phases of the life-cycle process are loosely mapped to the conceptual
framework of the spiral model.
The phases are named to depict the state of the project.

The size of the spiral corresponds to the inertia of the project with respect to the breadth
and depth of the artifacts that are developed.
The inertia manifests itself in maintaining artifact consistency, regression testing,
documentation, quality analyses, and configuration control.
Increased inertia may have very less direct impact on changing any given discrete
component or activity.
The reaction time for accommodating major architectural changes, major requirements
changes, major planning shifts, or major organizational changes clearly increases in
subsequent phases.
With in an iterative process, each phase includes all activities – requirements analysis,
design, coding, unit test, integration test, and system test – in varying proportions.
The primary objectives, essential activities, and general evaluation criteria for each phase
of the iterative process are as follows.
5.2 INCEPTION PHASE
The goal of the inception phase is to achieve concurrence among stakeholders on the
lifecycle
objectives for the project.
P
RIMARY OBJECTIVES
􀀈 Establishing the project’s software scope and boundary conditions, including an
operational concept, acceptance criteria, and a clear understanding of what is and
is not intended to be in the product.
􀀈 Discriminating the critical use cases of the system and the primary scenarios of
operation that will drive th4e major design trade-offs.
􀀈 Demonstrating at least one candidate architecture against some of the primary
scenarios.
􀀈 Estimating the cost and schedule for the entire project, including detailed
estimates for the elaboration phase.
􀀈 Estimating potential risks – sources of unpredictability.
E
SSENTIAL ACTIVITIES
􀀈 Formulating the scope of the project.
􀂃 This activity involves capturing the requirements and operational concept in an
information repository that describes user’s view of the requirements.
􀂃 The repository should be sufficient to define the problem space and derive the
acceptance criteria for the end product.
Engineering Stage Production Stage
Inception Elaboration Construction Transition
FIGURE 5-1. The phases of the life-cycle process
Idea Architecture Beta Releases Products
􀀈 Synthesizing the architecture.

􀂃 Design trade-offs, problem space ambiguities, and available solution-space
assets – technologies and existing components – are evaluated.
􀂃 An information repository is created that is sufficient to demonstrate the
feasibility of at least one candidate architecture and an initial baseline of make/
buy decisions so that cost, schedule, and resource estimates can be derived.
􀀈 Planning and preparing a business case.
􀂃 Alternatives for risk management, staffing, iteration plans, and cost/schedule/
profitability trade-offs are evaluated.
􀂃 The infrastructure – tools, processes, automation support – sufficient to support
the life-cycle development task is determined.
PRIMARY EVALUATION CRITERIA
􀀈 Do all stakeholders concur on the scope definition and cost and schedule
estimates?
􀀈 Are requirements understood, as evidenced by the fidelity of the critical use cases?
􀀈 Are the cost and schedule estimates, priorities, risks, and development processes
credible?
􀀈 Do the depth and breadth of an architecture prototype demonstrate the preceding
criteria?
􀀈 Are actual resource expenditures versus planned expenditures acceptable?
5.3 ELABORATION PHASE
The elaboration phase is the most critical of the four phases.
At the end of this phase, the “engineering” is considered complete and the project is
ready for making the decision whether or not to commit to the production phase.
This decision corresponds to the transition for an operation with low risk to an operation
with higher cost risk and substantial inertia.
The elaboration phase activities – should accommodate changes – must ensure that the
architecture, requirements, and plans are stable and the risks sufficiently reduced, that the
cost and schedule for the completion of the development can be predicted within an
acceptable range.
This level of fidelity would correspond to that necessary for an organization to commit to
a fixed-price construction phase.
During elaboration phase, an executable architecture prototype is built in one or more
iterations, depending on the scope, size, risk, a novelty of the project.
This effort addresses at least the critical use cases identified in the inception phase, which
expose the top technical risks of the project.
The development of one more exploratory, throw-away prototypes to mitigate specific
risks like design/requirement trade-offs, component feasibility analyses, or demonstration
to investors is also justified in place of the achievement of a prototype of
productionquality
components.
PRIMARY OBJECTIVES
􀀈 Preparing a baseline architecture as rapidly as practical while establishing a
configuration-managed snapshot with all changed rationalized, tracked and
maintained.
􀀈 Preparing a baseline of the vision.
􀀈 Preparing a baseline of a high-fidelity plan for the construction phase.
􀀈 Demonstrating that the baseline architecture will support the vision at a
reasonable cost in a reasonable time.
ESSENTIAL ACTIVITIES
􀀈 Elaborating the vision.
􀂃 This activity involves establishing a high-fidelity understanding of the critical
use cases that drive architectural or planning decisions.
􀀈 Elaborating the process and infrastructure.
􀂃 The construction process, the tools and process automation support, and the
intermediate milestones and their respective evaluation criteria are established.
􀀈 Elaborating the architecture and selecting components.

􀂃 Potential components are evaluated and make/buy decisions are sufficiently
understood so that construction phase cost and schedule can be determined with
confidence.
􀂃 The selected architectural components are integrated and assessed against the
primary scenarios.
􀂃 Lesson are learned from these activities result in a redesign of the architecture
as alternative designs are considered or the requirements are reconsidered.
􀀈 Is the vision stable?
􀀈 Is the architecture stable?
􀀈 Does the executable demonstration show the major risk elements are addressed
and credibly resolved?
􀀈 Is the construction phase plan of sufficient fidelity, and is it backed up with a
credible basis of estimate?
􀀈 Do all stakeholders agree that the current vision can be met if the current plan is
executed to develop the complete system in the context of the current architecture?
5.4 CONSTRUCTION PHASE
During the construction phase:
􀂾 All remaining components and application features are integrated into the
application, and
􀂾 All features are thoroughly tested.
The construction phase represents a production process with emphasis on managing
resources and controlling operations to optimize costs, schedules, and quality.
The management mindset undergoes a transition from the development of intellectual
property during inception and elaboration activities to the development of deployable
products during construction and transition activities.
In large projects parallel construction increments can be spawned to accelerate the
availability of deployable releases, to increase the complexity of resource management
and synchronization of workflows and teams.
The balanced development of the architecture and the plan is stressed during the
elaboration phase.
PRIMARY OBJECTIVES
􀀈 Minimizing development costs by optimizing resources and avoiding unnecessary
scrap and rework.
􀀈 Achieving adequate quality as rapidly as practical.
􀀈 Achieving useful versions as rapidly as practical
􀀈 Resource management, control, and process optimization
􀀈 Complete component development and testing against evaluation criteria
􀀈 Assessment of product releases against acceptance criteria of the vision
􀀈 Is this product baseline mature enough to be deployed?
􀀈 Is this product baseline stable enough to be deployed?
􀀈 Are the stakeholders ready for transition to the user community?
5.5 TRANSITION PHASE
The transition phase is entered when a baseline is mature enough to be deployed in the
end-user domain.
This requires a usable subset of the system is achieved with acceptable quality levels and
user documentation so that transition to the user will provide positive results.
This phase could involve any of the following activities:

1.Beta testing to validate the new system against user expectations
2.Beta testing and parallel operation relative to a legacy system it is replacing
3.Conversion of operational databases
4.Training of users and maintainers
The transition phase concludes with the deployment baseline achieving the complete
vision.
This life-cycle end point may coincide – for some projects – with the life-cycle starting
point for the next version of the product.
For other projects, it may coincide with a complete delivery of the information sets to a
third party responsible for operation, maintenance, and enhancement.
This phase – focusing on placing the software into the hands of the users – includes
several iterations, including beta releases, general availability releases, and bug-fix and
enhancement releases.
Considerable effort is expended in developing user-oriented documentation, training
users, supporting users in their initial product use, and reacting to user feedback. The
feedback should be confined to product tuning, configuring, installing, and usability
issues, at this stage of the life-cycle.
PRIMARY OBJECTIVES
􀀈 Achieving user self-supportability
􀀈 Achieving stakeholder concurrence that deployment baselines are complete and
consistent with the evaluation criteria of the vision.
􀀈 Achieving final product baselines as rapidly and const-effectively as practical.
􀀈 Synchronization and integration of concurrent construction increments into
consistent deployment baselines.
􀀈 Deployment-specific engineering – cutover, commercial packaging and
production, sales rollout kit development, field personnel training.
􀀈 Assessment of deployment baselines against the complete vision and acceptance
criteria in the requirements set.
􀀈 Is the user satisfied?
Each of the four phases consists of one or more iterations in which some technical
capability is produced in demonstrable form and assessed against a set of criteria.
An iteration
􀂾 Represents a sequence of activities for which there is a well-defined intermediate
event – a milestone;
􀂾 The scope and results of the iteration are captured via discrete artifacts.
Major milestones at the end of each phase use formal – stakeholder-approved – versions
of evaluation criteria and release descriptions,
Minor milestones use informal – internally controlled – versions of the artifacts.
Each phase corresponds to the completion of a sufficient number of iterations to achieve
a given overall project state.
The transition form one phase to the next maps more to a significant business decision
than to the completion of a specific development activity.
These intermediate phase transitions are the primary anchor points of the software
process, when technical and management perspectives are brought into synchronization
and agreement among the stakeholders is achieved with respect to the current
understanding of the requirements, design, and plan to complete.

1. List out and explain the life-cycle phases of a modern software development
process using a process diagram, clearly indicating the objectives, activities and
evaluation criteria of each phase.
2. Explain the differences in the emphasis between the engineering and production
stages of software development with reference to different life-cycle aspects.
3. For each of the INCEPTION, ELABORATION, CONSTRUCTION, and
TRANSITION phases explain
a. the starting and ending points,
b. objectives
c. activities
d. evaluation criteria.
CHAPTER – 6 ARTIFACTS OF THE PROCESS Page 46 of 187
Conventional software projects focused on the sequential development of software

artifacts:
a) Build the requirements
b) Construct a design model traceable to the requirements
c) Build an implementation traceable to the design model
d) Compile and test the implementation for deployment.
This process is suitable for small-scale, custom developments in which the design
representation, implementation representation, and deployment representation are closely
aligned.
This approach doesn’t work well for systems in which multi-dimensional complexity
results in numerous risks and subtle traceability relationships.
Modern systems are composed of numerous components – custom, reused, and
commercial products – intended to execute in a heterogeneous network of distributed
platforms.
They require a very different sequence of artifact evolution and a very different approach
to traceability.
Today, the software industry has matured and transitioned the management process to be
iterative.
Instead of being built sequentially, the artifacts are evolved together, and the constraints,
the different levels of abstractions, and the degrees of freedom are balanced among
competing alternatives.
Artifacts do not evolve in a one-way, linear progression.
Choices about implementation and deployment affect the way in which the requirements
are stated and the way in which the design proceeds.
Information and decisions can flow in various ways among artifacts.
A good development process removes inappropriate, premature constraints on the design
and accommodates the real engineering constraints.
In iterative development, the focus of activities sweeps across artifacts repeatedly,
incrementally enriching the entire system description and the process with the lessons
learned in preserving balance across the breadth and depth of information.
6.1 THE ARTIFACT SETS
To make the development of a complete software system manageable, distinct collections
of information are organized into artifact sets.
Each set comprises related artifacts that are persistent and in a uniform representation
format – such as English text, C++, Visual Basic, a standard document template, a
standard spreadsheet template, or a UML model.
A set represents a complete aspect of the system.
An artifact represents cohesive information that typically is developed and reviewed as a
single entity.
Even in trivial (or unnecessary) artifacts and sets, some information must be captured to
satisfy all stakeholders.
Life-cycle software artifacts are organized into five distinct sets that are partitioned
(roughly) by the underlying language of the set:
The Management Set
① Management (ad hoc textual formats)
The Engineering Sets
② Requirements (organized text and models of the problem space)
③ Design (models of the solution space)
④ Implementation (human-readable programming language and associated source
files)
⑤ Deployment (machine-executable languages and associated files)
A major technological advance has been the emergence of engineering notations for
requirements and design artifacts that support architecture-first development.
The UML is a suitable representation format in the form of visual models with a
welldefined
syntax and semantics for requirements and design artifacts. Visual modeling
using UML is a primitive notation for early life-cycle artifacts.
FIGURE 6-1. Overview of the artifact sets
Requirements Set Design Set Implementation Set Deployment Set
1. Vision document 1. Design model(s) 1. Source code
baselines
1. Integrated product
executable baselines
2. Requirements
model(s)
2. Test model 2. Associated
compile-time files
2. Associated run-time
files
3. Software architecture
description
3. Component
executables
3. User manual
Management Set
Planning Artifacts Operational artifacts
1. Work breakdown structure
2. Business case
3. Release specification
4. Software development plan
5. Released descriptions
6. Status assessments
7. Software change order database
8. Deployment documents
9. Environment
6.1.1 THE MANAGEMENT SET
The management set captures the artifacts associated with process planning and
execution.
These artifacts use ad hoc notations, including text, graphics, etc., to capture the
“contracts”
a) among project personnel – project management, architects, developers, testers,
marketers, administrators
b) among stakeholders – funding authority, user, software project manager,
organization manager, regulatory agency
c) and between project personnel and stakeholders.
Specific artifacts included in this set are:
a) The work breakdown structure – activity breakdown, and financial tracking
mechanism
b) The business case – cost, schedule, profit expectations
c) The release specifications – scope, plan, objectives for release baselines
d) The software development plan – project process instance
e) The release descriptions – results of release baselines
f) The status assessments – periodic snapshots of project progress
g) The software change orders – descriptions of discrete baseline changes
h) The deployment documents – cutover plan, training course, sales rollout kit
i) The environment – hardware and software tools, process automation,
documentation, training collateral necessary to support the execution
Management set artifacts are evaluated, assessed, and measured through a combination of
the following:
􀂃 Relevant stakeholder review
􀂃 Analysis of changes between the current version of the artifact and previous
versions – management trends and project performance changes in terms of cost,
schedule, and quality
􀂃 Major milestone demonstrations of the balance among all artifacts and, in
particular the accuracy of the business case and vision artifacts
6.1.2 THE ENGINEERING SETS
The engineering sets consist of
1) The requirement set
2) The design set
3) The implementation set
4) The deployment set.
The primary mechanism for evaluating the evolving quality of each artifact set is the
transitioning of information from set to set, and
Thereby maintaining a balance of understanding among the requirements, design,
implementation, and deployment artifacts
Each of these components of the system description evolves over time.
Requirement Set
Structured text is used for the vision statement to document the project scope that
supports the contract between the funding authority and the project team.
Ad hoc formats may also be used for
Supplementary specifications – such as regulatory requirements
User mockups or other prototypes that capture requirements
UML notation is used for engineering representations of requirements model – use case
models, domain models.
The requirements set is the primary engineering context for evaluating the other three
engineering artifact sets and is the basis for test cases.
Requirements artifacts are evaluated, assessed, and measured through a combination of
the following:
􀂃 Analysis of consistency with the release specifications of the management set.
􀂃 Analysis of consistency between the vision and the requirements models
􀂃 Mapping against design, implementation, and deployment sets to evaluate the
consistency and completeness and the semantic balance between information in the
different sets.
􀂃 Analysis of changes between the current version of requirements artifacts and
previous versions – scrap, rework, and defect elimination trends
􀂃 Subjective review of other dimensions of quality
Design Set
UML notation is used to engineer the design models for the solution.
The design set contains varying levels of abstraction that represent the components of the
solution space – their identities, attributes, static relationships, dynamic interactions.
The design models include structural and behavioral information to ascertain the
following costs:
􀂾 Bill of materials – quantity and specification of primitive parts and materials,
labor and other costs
Design model information can be straightforwardly and automatically translated into a
subset of the implementation and deployment set artifacts.
Specific design set artifacts include
􀂃 The design model
􀂃 The test model
􀂃 The software architecture description – an extract of information from the design
model that is pertinent to describing an architecture.
The design set is evaluated, assessed and measured through a combination of the
following:
􀂃 Analysis of the internal consistency and quality of the design model
􀂃 Analysis of consistency with requirements models
􀂃 Translation into implementation and deployment sets and notations – traceability,
source code generation, compilation, linking – to evaluate the consistency and
completeness and the semantic balance between information in the sets.
􀂃 Analysis of changes between the current version of the design model and previous
versions – scrap, rework, and defect elimination trends
Human analysis is required as the level of automated analysis of design models is limited.
Automated analysis will improve with the maturity of design model analysis tools that
support metrics collection, complexity analysis, style analysis, heuristic analysis, and
consistency analysis.
Implementation Set
Implementation sets are human-readable formats.
The implementation set includes
① Source code – programming language notations – that represents the tangible
implementations of components – their form, interface, and dependency
relationships
② Executables necessary for stand-alone testing of components.
These executables are the primitive parts needed to construct the end product, including
⒜ custom components, ⒝ application programming interfaces (APIs) of commercial
components, and ⒞APIs or reusable or legacy components in a programming language
source like Ada 95, C++, Visual Basic, Java, or Assembly.
Implementation set artifacts can also be translated – compiled and linked – into a subset
of deployment set – end-target executables.
Specific artifacts include
􀂃 Self-documenting product source code baselines and associated files –
compilation scripts, configuration management infrastructure, data files
􀂃 Self-documenting test source code baselines and associated files – input test
data files, test result files
􀂃 Standalone component executables
􀂃 Component test driver executables
The implementation sets are evaluated, assessed and measured through a combination of
the following:
􀂃 Analysis of consistency with the design models
􀂃 Translation into deployment set notations – compilation and linking – to evaluate the
consistency and completeness among the artifact sets
􀂃 Assessment of component source or executable files against relevant evaluation
criteria through inspection, analysis, demonstration, or testing
􀂃 Execution of standalone component test cases that automatically compare expected
results with the actual results
􀂃 Analysis of changes between the current version of the implementation set and
previous versions – scrap, rework, and defect elimination trends
Deployment Set
అ) The deployment set includes
ఆ) User deliverables and machine language notations
ఇ) Executable software
ఈ) The build scripts
ఉ) Installation scripts
ఊ) Executable target specific data necessary to use the product in its environment
The machine language notations represent the product components in the target form
intended for distribution to the user.
Deployment set information can be
① Installed
② Executed against (test) scenarios of use
③ Dynamically configured to support the features required in the end-product.
Specific artifacts include
∙ Executable baselines and associated run-time files
∙ The user manual
The deployment sets are evaluated, assessed and measured through a combination of the
following:
􀂃 Testing against the usage scenarios and quality attributes defined in the requirements
set to evaluate the consistency and completeness and the semantic balance between
information in the two sets
􀂃 Testing the portioning, replication, and allocation strategies in mapping components
of the implementation set to physical resources of deployment system – platform type,
number, network topology
􀂃 Testing against the defined usage scenarios in the user manual such as installation,
user-oriented dynamic reconfiguration, mainstream usage, and anomaly management.
􀂃 Analysis of changes between the current version of the deployment set and previous
versions –defect elimination trends, performance changes
The goal of selecting the management, requirements, design, implementation, and
deployment sets – though not scientific – is to optimize presentation of the process
activities, artifacts, and objectives.
These generalizations – with minor exceptions – as part of the conceptual framework are
useful in understanding the overall artifact sets.
Each artifact set uses different notations to capture the relevant artifacts.
Management set notations – ad hoc text, graphics, sue case notation – capture the plans,
process, objectives, and acceptance criteria.
Requirements notations – structured text and UML models – capture the engineering
context and operational concept.
Design notations – in UML – capture the engineering blueprints of architectural design,
and component design.
Implementation notations – software languages – capture the building blocks of the
solution in human-readable formats.
Deployment notations – executables and data files – capture the solution in
machinereadable
formats.
Each artifact set is the predominant development focus of one phase of the life cycle; the
other sets take on check and balance roles.
FIGURE 6-2. Life-cycle focus on artifact sets
Referring to the above figure, each phase has a predominant focus:
Requirements are the focus of the inception phase,
Management Constant level
Constant level
Constant level
Constant level
Requirements Focus
Design Focus
Implementation Focus
Deployment Focus
Design is the focus of elaboration phase,

Implementation is the focus of construction phase,
Deployment is the focus of the transition phase.
The management artifacts also evolve across the life cycle at a constant level.
Current software development tools map closely to one of the five artifact sets:
1.Management: scheduling, workflow, defect tracking, change management,
documentation, spreadsheet, resource management, and presentation tools
2.Requirements: requirements management tools
3.Design: visual modeling tools
4.implementation: compilers/debuggers, code analysis tools, test coverage analysis
tools, and test management tools
5.Deployment: test coverage and test automation tools, network management tools,
commercial components – operating systems, GUIs, DBMSs, networks, middleware
– and installation tools
Allocation of responsibilities among project teams is straightforward and aligns with the
process workflows.
Implementation Set versus Deployment Set
Because of the difference in concerns with respect to the source code in the
implementation set and the executable code in deployment set, the separation between
them is important.
The structure of information delivered to the user or test organization is different from
that of the source code.
Engineering decisions that have an impact on the quality of the deployment set but are
relatively incomprehensible in the design and implementation sets include the following:
􀀈 Dynamically configurable parameters – buffer sizes, color palettes, number of
servers, number of simultaneous clients, data files, run-time parameters
􀀈 Effect of compile/link-time optimizations – space optimization versus speed
optimization
􀀈 Performance under certain allocation strategies – centralized versus distributed,
primary versus shadow threads, dynamic load balancing, hot backup versus
checkpoint/rollback
􀀈 Virtual machine constraints – file descriptions, garbage collection, heap size,
maximum record size, disk file rotations
􀀈 Process-level concurrency issues – deadlock and race conditions
􀀈 Platform-specific differences in performance or behavior
This configuration information is important engineering source data that should be
captured either in the implementation set – if it is embedded within source code, or in the
deployment set – if it is embedded within data files, configuration files, installation
scripts, or other target-specific components.
In dynamically reconfigurable systems or portable components, the source code
implementation concerns should be separated from the target environment concerns for
reasons of performance, dynamic adaptability, or source code change management.
With this, the implementation can be decoupled from the actual platform type and from
the number and topology of the underlying computing infrastructure, including the
operating systems, middleware, networks, and DBMSs.
Deployment of commercial products to customers can also span a broad range of test and
deployment configurations.
For example: middleware products provide high-performance, reliable object request
brokers that are delivered on several platform implementations, including workstation
operating systems, bare embedded processors, large mainframe operating systems, and
several real-time operating systems.
The product configurations support various compilers and languages as well as various
implementations of network software.
The heterogeneity of all the various target configurations results in the need for a highly
sophisticated source code structure and a huge suite of different deployment artifacts.
6.1.3 ARTIFACT EVOLUTION OVER THE LIFE CYCLE
Each state of development represents an amount of precision in the final system
description.
Early in the life cycle, precision is low and the representation is generally high.
Eventually, the precision of representation is high and eve4rything is specified in full
detail.
At any point in the life cycle, the five sets will be in different states of completeness.
They should be at compatible levels of detail and reasonably traceable to one another.
Performing detailed traceability and consistency analyses early in the life cycle has a low
return on investment.
As development proceeds, the architecture stabilizes, and maintaining traceability linkage
among artifact sets is worth the effort.
Each phase of development focuses on a particular artifact set.
At the end of each phase, the overall system state will have progressed on all sets, as
illustrated in figure 6-3.
The inception phase focuses mainly on critical requirements, usually with a secondary
focus on an initial deployment view, little focus on implementation except perhaps choice
of language and commercial components, and possibly some high-level focus on the
design architecture but not on design detail.
During the elaboration phase, there is more depth in requirements and more breadth in
the design set, and further work on implementation and deployment issues such as
performance trade-offs under primary scenarios and make/buy analyses.
FIGURE 6-3. Life-cycle evolution of the artifact sets
Elaboration phase activities include the generation of an executable prototype.
This prototype involves subsets of development in all four sets and specifically assesses
whether the interfaces and collaborations among components are consistent and complete
within the context of the system’s primary requirements and scenarios.
A portion of all four sets must be evolved to some level of completion before an
architecture baseline is established.
This requires sufficient assessment of the design set, implementation set, and deployment
set artifacts against the critical use cases of the requirements set to suggest that the
project can proceed predictably with well-understood risks.
The main focus of the construction phase is design and implementation.
Early in this phase, the focus should be the depth of the design artifacts.
Engineering Stage Production Stage
Management
Implementation
Deployment
Requirements
Design
Management
Implementation
Deployment
Requirements
Design
Management
Implementation
Deployment
Requirements
Design
Management
Implementation
Deployment
Requirements
Design
Requi
Require
Im
Desi
Implementati
Depl
Mana Manageme
Later on, the emphasis is on realizing the design in source code and individually tested
components.
This phase should drive the requirements, design, and implementation sets almost to
completion.
Substantial work is also done on the deployment set, at least to test one or a few instances
of the programmed system through a mechanism such as an alpha or beta release.
The main focus of the transition phase is on achieving consistency and completeness of
the deployment set in the context of other sets.
Residual defects are resolved, and feedback from alpha, beta, and system testing is
incorporated.
In the conventional system requirements are not specified upfront, and then do design,
and so forth.
In contrast, the entire system is evolved; decision about the deployment may affect
requirements, and not the other way around.
The key emphasis here is to break the conventional mold, in which the default
interpretation is that one set precedes another.
Instead, one state of the entire system evolves into a more elaborate state of the system,
involving evolution in each of the parts.
During the transition phase, traceability between the requirements set and the deployment
set is extremely important.
The evolving requirements set captures a mature and pr4ecise representation of the
stakeholders’ acceptance criteria, and the deployment set represents the actual end-user
product.
So, during the transition phase, completeness and consistency between the two sets is
important.
Traceability among the other sets is necessary only to the extent that it aids the
engineering or management activities.
6.1.4 TEST ARTIFACTS
How was it in the conventional system???????????
Conventional testing followed the same document-driven approach as for development.
Development teams built requirements documents, top-level design documents, and
detailed design documents before constructing any source files or executables.
Test teams built system test plan documents, system test procedure documents,
integration test plan documents, unit test plan documents, and unit test procedure
documents before building any test drivers, stubs, or instrumentation.
This document-driven approach caused the same problems for the test activities that it did
for the development activities.
In the modern process the same sets, notations, and artifacts for the products of test
activities are used as for the product development.
The necessary test infrastructure is being identified as a required subset of the end
product.
In the process, seve4ral engineering disciplines are forced into the process.
􀀈 The test artifacts must be developed concurrently with the product from inception
through deployment.
So, testing is a full-life-cycle activity, not a late life-cycle activity.
􀀈 The test artifacts are communicated, engineered, and developed within the same
artifact set as the developed product.
􀀈 The test artifacts are implemented in programmable and repeatable format like the
software.
􀀈 The test artifacts are documented in the same way as the product is documented.
􀀈 Developers of the test artifacts use the same tools, techniques, and training as the
software engineers developing the product.
These disciplines allow for significant levels of homogenization across project
workflows.
All the activities are carried out within the notations and techniques of the four sets used
for engineering artifacts. They do not use separate sequences of design and test
documents.
Interpersonal communications, stakeholder reviews, and engineering analyses can be
performed with fewer distinct formats, fewer ad hoc notations, less ambiguity, and higher
efficiency.
For assessment workflow, in addition to testing, inspection, analysis, and demonstration
are also used.
Testing refers to the explicit evaluation through execution of deployment set components
under controlled scenario with an expected and objective outcome.
Tests can be automated.
The test artifacts are highly project-specific. But, there is a relationship between test
artifacts and the other artifact sets.
For example: consider a project to perform seismic data processing for the purpose of oil
exploration.
This system has three fundamental subsystems:
(1) a sensor subsystem that captures raw seismic data in real time and delivers these
data to:
(2) a technical operations subsystem that converts raw data into an organized database
and manages queries to this database from
(3) a display subsystem that allows workstation operators to examine seismic data in
human-readable form.
Such a system would result in the following test artifacts:
∎ Management set.
􀂾 The release specifications and release descriptions capture the objectives,
evaluation criteria, and results of an intermediate milestone.
􀂾 These artifacts are the test plans and test results negotiate4d among internal
project teams.
􀂾 The software change order capture test results – defects, testability changes,
requirements ambiguities, and enhancements – and the closure criteria associated
with making a discrete change to a baseline.
∎ Requirements set.
􀂾 The system-level use cases capture the operational concept for the system and the
acceptance test case descriptions, including the expected behavior of the system
and its quality attributes.
􀂾 The entire system is a test artifact as it is the basis of all assessment activities
across the life-cycle.
∎ Design set.
􀂾 A test model for non-deliverable components needed to test the product baselines
is captured in the design set.
􀂾 These components include such design set artifacts as a seismic event simulation
for creating realistic sensor data; a “virtual operator” that can support unattended,
after-hours test cases; specific instrumentation suites for early demonstration of
resource usage; transaction rates or response times; and use case test drivers and
component stand-alone test drivers.
∎ Implementation set.
􀂾 Self-documenting source code representations for test components and test drivers
provide the equivalent test procedures and test scripts.
􀂾 These source files include human-readable data files representing certain
statically defined data sets that are explicit test source files.
􀂾 Output files from test drivers provide the equivalent of test reports.
∎ Deployment set.
􀂾 Executable versions of test components, test drivers, and data files are provided.
For any release, all the test artifacts and product artifacts are maintained using the same
baseline version identifier.
They are created, changed, and obsolesced as a consistent unit.
As test artifacts are captured using the same notations, methods, and tools, the approach
to testing is consistent with design and development.
This approach forces the evolving test artifacts to be maintained so that regression tsting
can be automated easily.
6.2 MANAGEMENT ARTIFACTS
The management set includes several artifacts that capture intermediate results and
ancillary information necessary to document the product/process legacy, maintain the
product, improve the product, and improve the process.
Here we look at a summary of the artifacts.
The word document can mean paper document or electronically transmitted information
in the form of processed data, reviews, etc.
Business Case
The business case artifact provides all the information necessary to determine whether the
project is worth investing in.
It details the expected revenue, expected cost, technical and management plans, and
backup data necessary to demonstrate risks and realism of the plans.
In large contractual procurements, the business case may be implemented in a full-scale
proposal with multiple volumes of information.
In a small-scale endeavor for a commercial product, it may be implemented in a brief
plan with an attached spreadsheet.
The main purpose is to transform the vision into economic terms so that an organization
can make an accurate ROI assessment.
The financial forecasts are evolutionary, updated with more accurate forecasts as the life
cycle progresses.
FIGURE 6-4. A typical/default outline for the business case:
Software Development Plan
The software development plan (SDP) elaborates the process framework into a fully
detailed plan.
It is the defining document for the project’s success.
It must comply with contract, comply with organization standards, evolve along with the
design and requirements, and be used consistently across all subordinate organizations
doing the software development.
I . Context (domain, market, scope)
II . Technical Approach
A . Feature set achievement plan
B . Quality achievement plan
C . Engineering trade -offs and technical risks
III . Management approach
A . Schedule and schedule risk assessment
B . Objective measures of success
IV. Evolutio nary appendixes
A . Financial Forecast
1 . Cost estimate
2 . Revenue estimate
3 . Bases of estimates
Two indications of useful SDP are periodic updating – it is not stagnant shelf-ware and
understanding and acceptance by managers and practitioners.
FIGURE 6-5. A default/typical outline for a software development plan
Work Breakdown Structure
A work breakdown structure (WBS) is the vehicle for budgeting and collecting costs. To
monitor and control a project’s financial performance, the software project manager
must have insight into project costs and how they are expended.
If the WBS is structured improperly, it can drive the evolving design and product
structure in the wrong direction.
Lower levels of a WBS should not be laid out until a commensurate level of stability in
the product structure is achieved. Otherwise, specific boundaries of accountability will
not be well-defined.
A functional breakdown in the WBS will result in functional decomposition in the
software.
Software Change Order Database
Managing change is one of the fundamental primitives of an iterative development
process.
With greater change freedom, a project can iterate more productively.
This flexibility increases the content, quality, and number of iterations that a project can
achieve within a given schedule.
Change freedom is achieved through automation.
The current iterative development environments carry the burden of change management.
Manual techniques for change management are quite inefficient.
So, the change management data have been elevated to a first-class management artifact
that is described as a database to instill the concept of a need for automation.
I. Context (scope, objectives)
II. Software development process
A. Project primitives
1. Life-cycle phases
2. Artifacts
3. Workflows
4. Checkpoints
B. Major milestone scope and content
C. Process improvement procedures
III. Software engineering environment
A. Process automation (hardware and software resource configuration)
B. Resource allocation procedures
(sharing across organization, security access)
IV. Software change management
A. Configuration control board plan and procedures
B. Software change order definitions and procedures
C. Configuration baseline definitions and procedures
V. Software assessment
A. Metrics collection and reporting procedures
B. Risk management procedures
(risk identification, tracking and resolution)
C. Status assessment plan
D. Acceptance test plan
VI. Standards and procedures
A. Standards and procedures for technical artifacts
VII. Evolutionary appendixes
A. Minor milestone scope and content
B. Human resources
(organization, staffing plan, training plan)
Once software is placed in a controlled baseline, all change must be formally tracked and
managed.
By automating data entry and maintaining change records on-line, most of the change
management bureaucracy and metrics collection and reporting activities can be
automated.
Release Specifications
The scope, plan, and objective evaluation criteria for each baseline release are derived
from the vision statement and other sources like make/buy analyses, risk management
concerns, architectural considerations, shots in the dark, implementation constraints,
quality thresholds.
These artifacts are to evolve along with the process, achieving greater fidelity as the life
cycle progresses and requirements understanding matures.
FIGURE 6-6. Default/Typical release specification outline
Status Assessments
Status assessments provide periodic snapshots of project health and status, including the
software project manager’s risk assessment, quality indicators, and management
indicators.
With varying periodicity, the forcing function must persist.
A good management process must ensure that the expectations of all stakeholders –
contractor, subcontractor, customer, and user – are synchronized and consistent.
The periodic assessment documents provide the critical mechanism
a) for managing everyone’s expectations throughout the life cycle;
b) for addressing, communicating, and resolving management issues, technical
issues, and project risks
c) for capturing project history.
They are the periodic heartbeat for management attention.
Typical status assessment should include a review of resources, personnel staffing,
financial – cost and revenue – data, top 10 risks, technical progress – metrics snapshots,
major milestone plans and results, total project/product scope, action items, and
followthrough.
Continuous open communications with objective data derived directly from on-going
activities and evolving product configurations are mandatory in any project.
Environment
An important emphasis is to define the development and maintenance environment as a
first-class artifact of the process.
A robust, integrated development environment must support automation of the
This should include requirements management, visual modeling, document automation,
host and target programming tools, automated regression testing, and continuous and
integrated change management, and feature and defect tracking.
Hiring good people and equipping them with good tools is a must for success.
I . Iteration Content
II . Measurable Objective s
A . Evaluation criteria
B . Follow-through approach
III .
.
Demonstration plan
A
.
Schedule of activities
B
.
Team responsibilities
IV
.
Operational scenarios
(use cases demonstrated)
A
B..
Demonstration procedures
Traceability to visio n and business case
.
.
Automation of the software development process provides payback in quality, the ability
to estimate costs and schedules, and overall productivity using a smaller team.
By allowing the designers to traverse quickly among development artifacts and easily
keep the artifacts up-to-date, integrated toolsets play an increasingly important role in
incremental and iterative development.
Deployment
A deployment document can take many forms:
Depending on the project it could involve several document subsets for transitioning the
product into operational status.
In big contractual efforts in which the system is delivered to a separate maintenance
organization, deployment artifacts may include computer system operations manuals,
software installation manuals, plans and procedures for cutover, site surveys, and so on.
For commercial software products, deployment artifacts may include marketing plans,
sales rollout kits, and training courses.
Management Artifact Sequences
In each phase of the life cycle, new artifacts are produced and previous developed ones
are updated to incorporate lesson learned and to capture further depth and breadth of the
solution.
Some artifacts are updated at each major milestone, others at each minor milestone.
FIGURE 6-8. Artifact sequences across a typical life cycle
Inception Elaboration 􀁓 Controlled Construction Transition
baseline
􀁕 Informal
version
Iteration 1 Iteration 2 Iteration 3 Iteration 4 Iteration 5 Iteration 6 Iteration 7
Management set
1. WBS 􀁓 􀁓 􀁓
2. Business case 􀁓 􀁓 􀁓
3. Release specifications 􀁕 􀁓 􀁓 􀁓 􀁓 􀁓
4. Software development plan􀁓 􀁓
5. Release descriptions 􀁕 􀁕 􀁓 􀁓 􀁓 􀁓 􀁓
6. Status assessments 􀁕􀁕 􀁕􀁕 􀁕􀁕 􀁕􀁕 􀁕􀁕 􀁕􀁕 􀁕􀁕
7. Software change order data 􀁓 􀁓 􀁓 􀁓
8. Deployment documents 􀁕 􀁕 􀁓
9. environment 􀁕 􀁓 􀁓
Requirements set
1. Vision document 􀁓 􀁓 􀁓
2. Requirements model(s) 􀁓 􀁓 􀁓
Design set
1. Design model(s) 􀁕 􀁓 􀁓
2. Test model 􀁕 􀁓 􀁓
3. Architecture description 􀁕 􀁓 􀁓
Implementation set
1. Source code baselines 􀁓 􀁓 􀁓 􀁓 􀁓
2. Associated compile-time files 􀁓 􀁓 􀁓 􀁓 􀁓
3. Component executables 􀁓 􀁓 􀁓 􀁓 􀁓
Deployment Set
1. Integrated product-executable baselines 􀁓 􀁓 􀁓 􀁓 􀁓
2. Associated run-time files 􀁓 􀁓 􀁓 􀁓 􀁓
3. User manual 􀁕 􀁓
6.3 ENGINEERING ARTIFACTS
Most of the engineering artifacts are captured in rigorous engineering notations such as
UML, programming languages, or executable code.
In the project management course, three engineering artifacts are to be explicitly

reviewed. They are:
Vision Document
The vision document provides a complete vision for the software system under
development and supports the contract between the funding authority and the
development organization.
Every project – irrespective of its size – needs a source for capturing the expectations
among its stakeholders.
A project vision is meant to be changeable as understanding evolves of the requirements,
architecture, plans, and technology.
A good vision document should change slowly.
FIGURE 6-9. Default/Typical vision document
The vision document is written from the user’s perspective, focusing on the essential
features of the system and acceptable levels of quality.
The vision document should have at least two appendixes:
The first appendix should describe the operational concept using use cases – a visual
model and a separate artifact.
The second appendix should describe the change risks inherent in the vision statement, to
guide defensive design efforts.
The vision statement should include a description of what will be included as well as
those features considered but not included.
It should also specify operational capacities – volumes, response times, accuracies, user
profiles, and inter-operational interfaces with entities outside the system boundary.
The vision should not be defined only for the initial operating level; its likely evolution
path should be addressed so that there is a context for assessing design adaptability.
The operational concept involves specifying the use cases and scenarios for nominal and
off-nominal usage.
The use case representation provides a dynamic context for understanding and refining
the scope, for assessing the integrity of a design model, and for developing acceptance
test procedures.
The vision document provides the contractual basis for the requirements visible to the
stakeholders.
Architecture Description
The architecture description provides an organized view of the software architecture
under development.
It is extracted largely from the design model and includes views of the design,
implementation, and deployment sets sufficient to understand how the operational
concept of the requirements set will be achieved.
The breadth of the architecture description depends on the project being developed.
The architecture can described using a subset of the design model or as an abstraction of
the design model with supplementary material, or a combination of both.
As an example of the above two, consider the organization of a book:
I. Feature set description
A. Precedence and priority
II. Quality attributes and ranges
III. Required constraints
A. External interfaces
IV. Evolutionary appendixes
A. Use cases
1. Primary scenarios
2. Acceptance criteria and tolerances
B. Desired freedoms (potential change scenarios)
􀁑A subset form is satisfied by the table of contents. This description of the
architecture of the book can be derived directly from the book itself.
􀁑An abstraction form could be satisfied by a “Cliffs Notes” treatment. Cliffs notes
are condensed versions of classic books used as study guides. This format is an
abstraction developed separately and includes supplementary material that is not
directly derivable from the evolving product.
FIGURE 6-10. Default/typical architecture description outline
Software User Manual
The software user manual provides the user with the reference documentation necessary
to support the delivered software.
The user manual includes installation procedures, usage procedures and guidance,
operational constraints, and a user interface description, at a minimum even when varying
from project to project.
The manual should be developed early for products with user interfaces, as it is a
necessary mechanism for communicating and stabilizing an important subset of
requirements.
The user manual should be written by members of the test team, who are more likely to
understand the user’s perspective than the development team.
If the test team is responsible for the manual, it can be generated in parallel with
development and can be evolved early as a tangible and relevant perspective of
evaluation criteria.
It also provides a necessary basis for test plans and test cases, and for construction of
automated test suites.
6.4 PRAGMATIC ARTIFACTS
Conventional document-driven approaches wasted lots of amounts of engineering time on
developing, refining, formatting, reviewing, updating, and distributing documents.
There are several reasons that documents became so important to the process:
First, there were no rigorous engineering methods or languages for requirements
specification or design.
So, paper documents with ad hoc text and graphical representations were the
default format.
Second, conventional languages of implementation and deployment were extremely
cryptic and highly unstructured.
To present the details of software structure and behavior to other reviewers –
testers, maintainers, mangers – a more human-readable format was needed.
Third, and most important, software progress needed to be “credibly” assessed.
Documents represented a tangible but misleading mechanism for demonstrating
progress.
Document-driven approaches have degenerated into major obstacles to process
improvement. The quality of documents became more important than the quality of
engineering information they represented.
I. Architecture overview
A. Objectives
B. Constraints
C. Freedoms
II. Architecture views
A. Design view
B. Process view
C. Component view
D. Deployment
III. Architectural interactions
A. Operational concept under primary scenarios
B. Operational concept under secondary scenarios
C. Operational concept under anomalous conditions
IV. Architecture performance
V. Rationale, trade-offs, and other substantiation
Evaluating quality through human review of abstract descriptions is a highly subjective

process.
More effort was devoted to assess the single-dimensional surface issues, with very little
attention paid to the multi-dimensional issues that drive architecture qualities like
performance and adaptability.
Document production cycles, review cycles, and update cycles also injected visible and
formal snapshots of progress into the schedule – introducing more schedule dependencies
and synchronization points.
Lengthy and highly detailed documents – perceived to demonstrate progress – resulted in
premature engineering details and increased scrap and rework later in the life cycle.
A more effective approach is to redirect this documentation effort to improving the rigor
and understandability of the information source and allowing on-line review.
Such an approach can eliminate a huge, unproductive source of scrap and rework in the
process and allow for continuous review by all the stakeholders.
This philosophy raises the following cultural issues:
People want to review information but don’t understand the language of the
artifact.
Reviewers may resist learning the engineering language in which the artifact is
written.
Patronizing such audiences should be stopped as they typically add cost and time
to the process without adding value.
People want to review the information but don’t have access to the tools.
When the development tools are not available to the reviewers, it results in
exchange of paper documents.
Standardized formats – UML, spreadsheets, Visual Basic, C++, and Ada 95,
visualization tools, and the Web are making it economically feasible for all
stakeholders to exchange information electronically.
If the reviewers don’t accept this feature, it pollutes the software development
process.
Human-readable engineering artifacts should use rigorous notations that are
complete, consistent, and used in self-documenting manner.
Properly spelled English words should be used for all identifiers and descriptions.
Acronyms and abbreviations should be used only for well accepted jargon only.
Abbreviations introduce errors throughout the life cycle, though they simplify the
document preparer’s life.
Disallowing this practice pays off in productivity and quality.
Readability should be emphasized to enable understandable representations,
brows-able formats, more-rigorous notations, and reduced error rates.
Useful documentation is self-defining: It is documentation that gets used.
Building self-documenting artifacts gives the scope to work solely in the
engineering notations and avoid separate documents to describe all the details of a
model, component, or test procedure.
If any information or document is produced but not used, it should be avoided in
favor of something more useful to accomplish the intended purpose.
Paper is tangible; electronic artifacts are too easy to change.
Paper documents are preferred as they are tangible, static, and persistent.
On-line and Web-based artifacts can be changed easily and reviewed with more
skepticism because of their inherent volatility.
The advantages of electronic artifacts – in spite of the obvious skepticism – are
substantial and far-reaching.
Tools and environments will evolve to support change management, audit trails,
digital signatures, and other advances in groupware so that electronic interchanges
replace paper.
It is important that information inherent in the artifact be emphasized, not the paper on
which it is written.
Short documents are more useful than the long ones.
Software is the primary product, documentation is merely support material.
Questions on this chapter
:
1. Using a neat diagram give an overview of the artifact sets in the software
2. Give a brief outline of the management artifact sets.
3. Give a brief outline of the engineering artifact sets.
4. Discuss the life-cycle focus on artifact sets in each phase.
5. Explain how test artifacts have evolved from the conventional process to the modern
process in terms of the test artifacts in each of the phases of the life cycle.
6. Trace the artifact evolution over the life cycle.
7. Describe different management artifacts, giving brief outlines of each.
8. Using a neat diagram, explain the sequences of artifacts across a typical life cycle.
9. Describe different engineering artifacts, giving brief outlines of each.
10. Explain the evolution of documentation from the paper-based to electronic based
bringing out the cultural issues involved.
CHAPTER-7 MODEL-BASED SOFTWARE ARCHITECTURES Page 63 of 187
Software architecture is the central design problem of a complex software system.

A software architecture has several dimensions of complexity.
The critical performance attributes and features of a complex software system are not
governed by any laws of physics or mathematics.
Software architectures have no irrefutable first principles. They are many heuristics and
fuzzy guidelines.
The fundamental measures of goodness are highly situation-dependent.
As there is no established theory, software architects have to rely on some form of
experimentation in formulating software architectures.
Early activities in the iterative processes emphasize and promote architecture evolution
through prototyping and demonstration. This is yet another reason to switch over to
iterative processes.
A model is a relatively independent abstraction of a system.
A view is a subset of a model that abstracts specific, relevant perspective.
7.1 ARCHITECTURE: A MANAGEMENT PERSPECTIVE
The most critical technical product of a software project is its architecture:
􀂾 The infrastructure, control, and data interfaces that permit software components to
cooperate as a system, and
􀂾 Software designers to cooperate efficiently as a team.
Accurate and precise communications must be established among teams of people, as
captured in the software architecture, for the success of the project.
Multiple languages and different literacy levels in the media can make the
communication problem more complex or even unsolvable.
The three different aspects of an architecture from a management perspective are:
1.An architecture (the intangible design concept) is the design of a software system in
contrast to the design of a component.
This includes all engineering necessary to give a complete specification of the required
infrastructure, significant make/buy decision resolutions, and elaboration of all custom
components.
This enables a confident determination of the costs involved.
2.An architecture baseline (the tangible artifacts) is the information about the
engineering artifacts required for satisfying all the stakeholders that the vision –
function and quality can be achieved within the parameters of the business case – cost,
profit, time, technology, and people.
3.An architecture description (a human-readable representation of an architecture, which
is one of the components of an architecture baseline) is an organize subset of
information extracted from the design set models.
It includes additional ad hoc notation to clarify the information in the models.
The architecture description communicates how the intangible concept is realized in the
form of tangible artifacts.
The importance of software architecture and its close linkage with modern software
development processes can be summarized as:
􀀩 When critical make/buy decisions are resolved, it represents a significant milestone as
part of a stable software architecture.
This life-cycle event represents a transition from the engineering stage to the
production stage.
􀀩 Architecture representations provide a basis for balancing the trade-offs between the
problem space – requirements and constraints, and the solution space – the
operational product.
􀀩 The architecture and process encapsulate many of the important communications
among individuals, teams, organizations, and stakeholders.
􀀩 Poor architectures and immature processes are given as reasons for failures.
􀀩 A mature process – an understanding of the primary requirements, and a
demonstrable architecture are important prerequisites for predictable planning.
􀀩 Architecture development and process definition are the intellectual steps that map
the problem to a solution without violating the constraints. They require innovation
and cannot be automated.
7.2 ARCHITECTURE: A TECHNICAL PERSPECTIVE

Software architecture encompasses
􀂾 the structure of software systems – the selection of elements and composition of
elements into progressively larger subsystems,
􀂾 their behavior – collaborations among elements, and
􀂾 patterns that guide these elements, their collaborations, and their composition.
This context must include functionality, performance, resilience, comprehensibility,
economic trade-offs, technology constraints, and aesthetic concerns.
The design model includes the full breadth and depth of information.
An architecture view is an abstraction of the design model. It contains only the
architecturally significant information.
Systems require four views: design, process, component, and deployment.
The purposes of these four views are:
􀁑Design: describes architecturally significant structures and functions of the design
model
􀁑Process: describes concurrency and control thread relationships among the design,
component, and deployment views
􀁑Component: describes the structure of the implementation set
􀁑Deployment: describes the structure of the deployment set
The design view is necessary for every system, and the others can be included depending
on the complexity of the system.
Figure 7-1 summarizes the artifacts of the design set, including architecture views and
architecture description.
The architecture description is captured electronically as a single printable document.
The engineering models and architectural views are collections of UML diagrams.
(A) The requirements model addresses the behavior of the system as seen by the
endusers,
analysts, and testers.
This view is modeled statically using use-case and class diagrams, and dynamically using
sequence, collaboration, state chart, and activity diagrams.
􀂾 The use case view describes how the system’s critical – architecturally significant –
use cases are realized by elements of the design model.
􀂾 It is modeled statically using use case diagrams, and dynamically using UML
behavioral diagrams.
(B) The design model addresses the architecture of the system and the design of the
components within the architecture, including functional structure, concurrency
structure, implementation structure and execution structure of the solution space, as
seen by its developers.
Static descriptions are provided with structural diagrams – class, object, component,
and deployment diagrams.
Dynamic descriptions are provided with UML behavioral – collaboration, sequence,
state chart, activity – diagrams.
􀂾 The design view describes the architecturally significant elements of the design model.
This view, an abstraction of the design model, addresses the basic structure and
functionality of the solution.
It is modeled statically using class and object diagrams, and dynamically using the
UML behavioral diagrams.
􀂾 The process view addresses the run-time collaboration issues involved in executing the
architecture on a distributed deployment model, including the logical software
network topology, interprocess communication, and state management.
This view is modeled statically using deployment diagrams, and dynamically using the
UML behavioral diagrams.
􀂾 The component view describes the architecturally significant elements of the
implementation set.
This view, an abstraction of the design model, addresses the software source code
realization of the system from the perspective of the project’s integrators and
developers, especially with regard to releases and configuration management.
It is modeled statically using component diagrams, and dynamically using the UML
􀂾 The deployment view addresses the executable realization of the system, including the
allocation of logical processes in distribution view to physical resources of the
deployment network.
It is modeled statically using deployment diagrams, and dynamically using the UML
ARCHITECTURAL DESCRIPTIONS take on different forms and styles in different
organizations and domains.
An architecture requires a subset of artifacts in each engineering set.
The actual level of content in each set is situation-dependent, and there are few good
heuristics for describing objectively what is architecturally significant.
Generally, an architecture baseline should include the following:
Requirements: critical use cases, system-level quality objectives, and priority
relationships among features and qualities.
Implementation
Requirements
Design
Deployment
The requirement set may
include UML models
describing the problem
space
The design set includes
all UML design models
describing the solution
Depending on its complexity, a system may require several
models or partitions of a single model.
Design
Model
Process
Model
Component
Model
Deployment
Model
Use Case
Model
The design, process, and
use case models provide
for visualization of the
logical and behavioral
aspects of the design.
The component model
provides for
visualization of the
implementation set.
The deployment model
provides for
visualization of the
dltt
An architecture is described through several views,
which are extracts of design models that capture
the significant structures, collaborations, and
Design
View
Process Component
View
Deployment
View
Use Case
View
Architecture
Description Document
Design view
Process view
Use case view
Component view
Other (optional) views
Other material:
􀂾 Rationale
􀂾 Constraints
View
FIGURE 7-1. Architecture, an organized and abstracted view into the design
dl
Design: names, attributes, structures, behaviors, groupings, and relationships of

significant classes and components.
Implementation: source component inventory and bill of materials – number, name,
purpose, cost – of all primitive components.
Deployment: executable components necessary to demonstrate the critical use cases and
the risk associated with achieving the system qualities.
The underlying spirit of architecture-first development is crucial to success, so technical
details of the architecture description are also included.
An architecture baseline is defined as a balanced subset of information across all sets,
whereas an architecture description is completely encapsulated within the design set.
The architecture description takes a wide range of forms: from a simple direct subset of
UML diagrams – applicable for a small, highly skilled team building a development tool,
to a complex set of models with a variety of distinct views that capture and
compartmentalize the concerns of a sophisticated system – suitable for a highly
distributed, large-scale, catastrophic-cost-of-failure command and control system.
The artifact sets evolve through a project life cycle form the engineering stage – where
focus is on the requirements and design artifacts, to the production stage – with focus on
the implementation and deployment artifacts.
The transition point form the engineering stage to the production stage constitutes a state
in which the project has achieved when relevant stakeholders agree that the vision can be
achieved with a highly predictable cost and schedule.
Support for this state requires not only briefings and documents, but also executable
prototypes that demonstrate evolving capabilities.
These demonstrations provide tangible feedback on the maturity of the solution.
The more standard components are used, the simpler this state is to achieve.
The more custom components are used, the harder it is to achieve and the harder it is to
estimate construction costs.
1. Define the terms: model, view, and architecture. (Page 110)
2. Describe the three different aspects of an architecture from the management
perspective. (Page 110/111 – 7.1)
3. Give a brief summary of the linkage between software architecture and modern
software development processes. (Page 111)
4. Explain the components of a software architecture in terms of the elements, their
composition, collaborations, etc. (Page 112/113)
5. Briefly summarize the artifacts of the design set. (Fig 7-1/Page 113).
6. Explain the components of an architecture baseline. (Page 114/115)
CHAPTER-8 WORKFLOWS OF THE PROCESS Page 67 of 187
Most process descriptions use sequences of activities as representation format.

Sequentially oriented process descriptions are simple to understand, represent, plan and
conduct.
Software projects are not sequential activities.
Software projects include many teams, progressing on many artifacts that must be
synchronized, cross-checked, homogenized, merged, and integrated.
Management complexity arises from distributed nature of the software process and its
subordinate workflows.
In the sequential way of the conventional process model, the main problem arises as the
details of each phase have to be completed and frozen before the next phase starts. In this
process important engineering decisions would either slow down or completely get
stopped.
The phase names in a modern process – inception, elaboration, construction, and
transition – specify the state of the project instead of a sequence of activities as in the
waterfall model.
The intent here, is to recognize explicitly the continuum of activities in all phases.
8.1 SOFTWARE PROCESS WORKFLOWS
A life-cycle macroprocess comprises discrete phases and iterations, but not discrete
activities.
A continuum of activities occurs in each phase and iteration.
The next-level process description is the microprocesses, or workflows, that produce the
artifacts.
The term workflow means a thread of cohesive and mostly sequential activities.
Workflows are mapped to product artifacts and to project teams.
There are seven top-level workflows:
1. Management workflow: controlling the process and ensuring win conditions for all
stakeholders.
2. Environment workflow: automating the process and evolving the maintenance
environment.
3. Requirements workflow: analyzing the problem space and evolving the requirements
artifacts.
4. Design workflow: modeling the solution and evolving the architecture and design
artifacts.
5. Implementation workflow: programming the components and evolving the
implementation and deployment artifacts.
6. Assessment workflow: assessing the trends in process and product quality.
7. Deployment workflow: transitioning the end products to the user.
The relative levels of effort expected across the phases in each of the top-level workflows
provide a view point towards several of the key principles:
1. Architecture-first approach.
2. Iterative life-cycle process.
3. Round-trip engineering.
4. Demonstration-based approach.
Some of the key themes of the conventional process not carried over in the workflows of
the
modern process are:
􀂾 Documentation
􀂾 Quality assurance
FIGURE 8-1. Activity levels across the life-cycle phases
The following table shows the allocation of artifacts and the emphasis of each workflow
in
each of the life-cycle phases of inception, elaboration, construction, and transition.
TABLE 8-1. The artifacts and life-cycle emphases association with each workflow
WORKFLOW ARTIFACTS LIFE-CYCLE PHASE EMPHASIS
Management
Environment
Requirements
Design
Implementation
Assessment
Deployment
Figure 8-1. Activity levels across the life-cycle phases
Management Business case
Software development
Plan
Status assessments
Vision
Work breakdown
structure
Inception: prepare business case and vision
Elaboration: Plan development
Construction: Monitor and control development
Transition: Monitor and control deployment
Environment Environment
Software change order
database
Inception: define development environment and
change management infrastructure
Elaboration: install development environment and
establish change management database
Construction: maintain development environment
and software change order database
Transition: transition management environment and
software change order database
Requirements Requirements set
Release specifications
Vision
Inception: define operational concept
Elaboration: define architecture objectives
Construction: define iteration objectives
Transition: refine release objectives
Design Design set
Architecture description
Inception: formulate architecture concept
Elaboration: achieve architecture baseline
Construction: design components
Transition: refine architecture and components
Implementation
Implementation set
Deployment set
Inception: support architecture prototypes
Elaboration: produce architecture baseline
Construction: produce complete componentry
Transition: maintain components
TABLE 8-1. The artifacts and life-cycle emphases association with each workflow
(Continued)
WORKFLOW ARTIFACTS LIFE-CYCLE PHASE EMPHASIS
8.2 ITERATION WORKFLOWS
An iteration consists of a loosely sequential set of activities in various proportions
depending
on where the iteration is located in the development cycle.
Each iteration is defined in terms of a set of allocated usage scenarios.
The components needed to implement the selected scenarios are developed and integrated
with the results of previous iterations.
An individual iteration’s workflow, generally, includes the following sequence:
􀂾 Management:
o iteration planning to determine the content of the release and develop the
detailed plan for iteration
o assignment of work packages/tasks to the development team
􀂾 Environment:
o evolving the software change order database to reflect all new baselines
and changes to existing baselines for all product, test, and environment
components.
􀂾 Requirements:
o analyzing the baseline plan, the baseline architecture, and the baseline
requirements set artifacts to fully elaborate the use cases to be
demonstrated at the end of this iteration and their evaluation criteria
o updating nay requirements set artifacts to reflect changes necessitated by
results of this iterations engineering activities.
􀂾 Design:
o evolving the baseline architecture and the baseline design set artifacts to
elaborate fully the design model and test model components necessary to
demonstrate against the evaluation criteria allocated to this iteration
o updating design set artifacts to reflect changes necessitated by the results
of this iteration’s engineering activities
Allocated usage
scenarios
Results from the
previous iteration
Management
Requirements
Design
Implementation
Assessment
Deployment
Results of the
next iteration
􀂾 Up-to-date risk assessment
􀂾 Controlled baselines artifacts
􀂾 Demonstrable results
o Requirements understanding
o Design features/performance
o Plan credibility
FIGURE 8-2.
The workflow of an iteration
Assessment Release specifications
Release descriptions
User manual
Deployment set
Inception: assess plans, vision, prototypes
Elaboration: assess architecture
Construction: assess interim releases
Transition: assess product releases
Deployment Deployment set Inception: analyze user community
Elaboration: define user manual
Construction: prepare transition materials
Transition: transition product to user
􀂾 Implementation:
o developing or acquiring any new components, and enhancing/modifying
any existing components, to demonstrate the evaluation criteria allocated
to this iteration
o integrating and testing all new/modified components with
existing baselines of the previous versions
􀂾 Assessment:
o evaluating the results of the iteration, including compliance with the
allocated evaluation criteria and the quality of the current baselines
o identifying any rework required and determining if it should be performed
before deployment of this release or allocated to the next release
o assessing results to improve the basis of the subsequent iteration’s plan
􀂾 Deployment:
o transitioning the release to an external organization or to internal closure
by conducting a post-mortem so that lessons learned can be captured and
reflected in the next iteration
Many of the activities in this sequence also occur concurrently.
For example, requirements analysis is not done all in one continuous lump; it
intermingles
with management, design, implementation, and so on.
Iterations in the inception and elaboration phases focus on management, requirements,
and
design activities.
Iterations in the construction phase focus on design, implementation, and assessment.
Iterations in the transition phase focus on assessment and deployment.
In practice, the various sequences and overlaps among iterations become more complex
The terms iteration and increment deal with some of the pragmatic considerations.
An iteration represents the state of the overall architecture and the complete deliverable
system.
An increment represents the current work in progress that will be combined with the
preceding iteration to form the next iteration.
Figure 8-4, an example of a simple development life cycle, illustrates the difference
between
iterations and increments.
A typical build sequence from the perspective of an abstract layered architecture is also
illustrated therein.
Management
Requirements
Design
Implementation
Assessment
Deployment
Management
Requirements
Design
Implementation
Assessment
Deployment
Management
Requirements
Design
Implementation
Assessment
Deployment
Inception and Elaboration phases Construction phase Transition phase
FIGURE 8-3. Iteration emphasis across the life cycle

1. List the seven top-level workflows and map them to product artifacts.
(P 118, Fig 8-1/P199)
2. Using a neat diagram, explain the workflow of an iteration. (Fig 8-2/P 121)
3. Explain the build sequence associated with a layered architecture with iteration
emphasis across the life cycle. (Fig. 8-3/P 123, Fig. 8-4/P124)
Progress
100%
Progress can be measured as the % of
components under configuration
control, the % of demonstrable use
Iteration 1 Iteration 2 Iteration 3
Increment 4
Increment 5
Increment 6 Iteration 7
Iteration 1 Iteration 2 Iteration 3 Iteration 4 Iteration 5 Iteration 6
Application specific components
6
6
35
15
55
25
6
Domain specific components
166
443
5
33
26
Middleware and common
mechanism components
5
5
2
2
4
4
21
Operating system and
networking components
121
23
133
Iteration 1 Iteration 2 Iteration 3
Increment 4
Increment 5
Increment 6 Iteration 7
Iterations 1, 2, and 3 include
architecturally significant
components
Iteration 7 adds no new
components, only upgrades,
fixes, and enhancements
FIGURE 8-4. A typical build sequence associated with a layered architecture
CHAPTER-9 CHECKPOINTS OF THE PROCESS Page 72 of 187
Visible milestones in the life cycle help in the discussions in the meetings of the
stakeholders.
The purpose of such meetings is:
a) to demonstrate the performance of a project
b) synchronize stakeholder expectations and achieve concurrence on the three
evolving perspectives – the requirements, the design, and the plan
c) synchronize related artifacts into a consistent and balanced state
d) identify the important risks, issues, and out-of-tolerance conditions
e) perform a global assessment for the whole life cycle.
Milestones must have well-defined expectations and provide tangible results.
This can include renegotiation of the milestone’s objectives after gaining understanding
of the trade-offs among the requirements, the design, and the plan.
Three types of joint management reviews are conducted throughout the process:
1. Major milestones: these system-wide events are held at the end of each
development phase.
They provide visibility to system-wide issues, synchronize the management and
engineering perspectives, and verify that the aims of the phase have been
achieved.
2. Minor milestones: these iteration-focused events are conducted to review the
content of an iteration in detail and to authorize continued work.
3. Status assessments: these periodic events provide management with frequent and
regular insight into the progress being made.
Each of the four phases – inception, elaboration, construction, and transition – consists of
one or more iterations and concludes with a major milestone when a planned technical
capability is produced in demonstrable form.
An iteration represents a cycle of activities for which there is a well-defined intermediate
result as a minor milestone. This is captured with two artifacts: 􀁣a release specification –
the evaluation criteria and plan, and 􀁤a release description – the results.
Major milestones at the end of each phase use formal stakeholder-approved evaluation
criteria and release descriptions.
Minor milestones use informal, development-team-controlled versions of these artifacts.
The number of milestones depends on such parameters as scale, number of stakeholders,
business context, technical risk, and sensitivity of cost and schedule perturbations.
9.1 MAJOR MILESTONES
As can be seen from figure 9-1, the four major milestones occur at the transition points
between life-cycle phases.
In an iterative model, the major milestones are used to achieve concurrence among all
stakeholders on the current state of the project.
The milestones can be conducted in one continuous meeting or incrementally through
online
reviews.
The essence of each major milestone is to ensure that the requirements understanding, the
life-cycle plans, and the product’s form, function, and quality are evolving in balanced
levels of detail and to ensure consistency among the various artifacts.
Major ▲ ▲ ▲ ▲
milestones Strategic focus on global concerns of the entire software project
Minor △ △ △ △ △ △ △
milestones Tactical focus on local concerns of the current iteration
Status ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇ ◇
assessments Periodic synchronization of stakeholder expectations
Iteration 1 Iteration 2 Iteration 3 Iteration 4 Iteration 5 Iteration 6 Iteration 7
Inception Elaboration Construction Inception
Life-cycle
objectives
milestone
Life-cycle
architecture
milestone
Initial
operational
capability
milestone
Product
release
milestone
FIGURE 9-1.
A typical
sequence of
stake-holder
expectations
Table 9-1 summarizes the balance of information across the major milestones.
Concerns of different stakeholders
Stakeholder Concern(s)
Customer Schedule and budget estimates, feasibility, risk assessment, requirements
understanding, progress, product line compatibility
Users Consistency with requirements and usage scenarios, potential for
accommodating growth
Architects and
systems
engineers
Product line compatibility, requirements changes, trade-offs analyses,
completeness and consistency, balance among risk, quality, and usability
Developers Sufficiency of requirements detail and usage scenario descriptions,
frameworks for component selection or development, resolution of
development risk, product line compatibility, sufficiency of the development
environment
Maintainers Sufficiency of product and documentation artifacts, understandability,
interoperability with existing systems, sufficiency of maintenance
environment
Others Perspectives by stakeholders like regulatory agencies, independent
verification and validation contractors, investors, contractors, and sales and
marketing teams
TABLE 9-1. The general status of plans, requirements, and products across the major
milestones
MILESTONES
PLANS
UNDERSTANDING
OF PROBLEM
SPACE
(REQUIREMENTS)
SOLUTION SPACE
PROGRESS
(SOFTWARE PRODUCT)
Definition of
stakeholder
responsibilities
Baseline vision,
including growth
vectors, quality
attributes, and
priorities
Demonstration of at least one
feasible architecture
Low-fidelity lifecycle
plan
Make/buy/reuse trade-offs
Life-cycle
objective
High-fidelity
elaboration phase
plan
Use case model
Initial design model
High-fidelity
construction phase
plan
Stable vision and use
case model
Stable design set
Evaluation criteria for
construction release,
initial operational
capability
Life-cycle Make/buy/reuse decisions
architecture
milestone
Low-fidelity
transition phase
plan
Draft user manual Critical component prototypes
Acceptance criteria
for product release
Stable implementation set
Critical features and core
capabilities
Initial operational
capability
milestone
High-fidelity
transition phase
plan Releasable user
manual
Objective insight into product
qualitites
Stable deployment set
Product release Full features
milestone
Next-generation
product plan
Final user manual
Compliant quality
TABLE 9-1. The general status of plans, requirements, and products across the major
milestones
Life-cycle Objectives Milestone

􀂾 The life-cycle objective milestone occurs at the end of the inception phase.
􀂾 The goal is to present to all stakeholders a recommendation on how to proceed with
development, including a plan, estimated cost and schedule, and expected benefits
and cost savings.
􀂾 A draft architecture document and a prototype architecture demonstration provide
evidence of the completeness of the vision and the software development plan.
􀂾 A successfully completed life-cycle objectives milestone results in authorization from
all stakeholders to proceed with the elaboration phase.
Life-cycle Architecture Milestone
The life-cycle architecture milestone occurs at the end of the elaboration phase.
The primary goal: to demonstrate an executable architecture to all stakeholders.
A detailed plan for the construction phase is presented for approval.
Critical issues relative to requirements and the operational concept are addressed.
This review, also, produces consensus on a baseline architecture, baseline vision, baseline
software development plan, and evaluation criteria for the initial operational capability
milestone.
A successfully completed life-cycle architecture milestone results in authorization from
the stakeholders to proceed with the construction phase.
The event that transitions the project from the elaboration phase to the construction phase
becomes the most important major milestone.
Achieving a software development state in which the research and development stage is
concluding and the production stage is being initiated forms this major milestone.
A software development project ready for this transition exhibits the following
characteristics:
① The critical use cases are defined, agreed upon by stakeholders, and codified into a set
of scenarios for evaluating the evolving architecture.
② A stable architecture is baselined in the source language format.
③ The risk profile is well understood, even without all the risks being resolved. Only the
outlines of the risks and the mitigation plans should be understood by all the
stakeholders.
The development plan for the construction and transition phases is defined with enough
fidelity that construction iterations can proceed with predictable results.
The content of this milestone should include, minimum, the following:
􀂾 A presentation and overview of the current project state
􀂾 A configuration-controlled set of engineering information
􀂾 An executable demonstration of capability
By the time of the life-cycle architecture milestone the following technical data should
have been reviewed:
Default agenda(s) for the life-cycle architecture milestone:
I. Requirements
A. Use case model
B. Vision document – text, use cases
C. Evaluation criteria for elaboration – text, scenarios
II. Architecture
A. Design view – object models
B. Process view – run-time layout, executable code structure
C. Component view – subsystem layout, make/buy/reuse component identification
D. Deployment view – target run-time layout, target executable code structure
E. Use case view – test case structure, test result expectation
1. Draft user manual
III. Source and executable libraries
A. Product components
B. Test components
C. Environment and tool components
FIGURE 9-2. Engineering artifacts available at the life-cycle architecture milestone
Initial Operational Capability Milestone

This occurs late in the construction phase.
The goals of this milestone are:
① to assess the readiness of the software to being the transition into customer/user sites,
② to authorize the start of acceptance testing.
Issues addressed:
􀀩 installation instructions,
􀀩 software version descriptions,
􀀩 user and operator manuals, and
􀀩 the ability of development organization to support user sites.
The initiation of transition is not the completion of the construction phase. They typically
overlap until an initial product is delivered to the user for self-sufficient operation.
Product release Milestone
This occurs at the end of the transition phase. The goal of this milestone is:
① to assess the completion of the software and its transition to the support organization.
􀀩 The results of the acceptance test are reviewed, and
Presentation Agenda
I. Scope and Objectives
A. Demonstration overview
II. Requirements assessment
A. Project vision and use cases
B. Primary scenarios and evaluation criteria
III. Architecture assessment
A. Progress
1. Baseline architecture metrics (progress to date and baseline for
measuring future architectural stability, scrap and rework)
2. Development metrics baseline estimate (for assessing future
progress)
3. Test metrics baseline estimate (for assessing future progress of
the test team)
B. Quality
1. Architectural features (demonstration capability summary vs.
evaluation criteria)
2. Performance (demonstration capability summary vs. evaluation
criteria)
3. Exposed architectural risks and resolution plans
4. Affordability and make/buy/reuse trade-offs
IV. Construction phase plan assessment
A. Iteration content and use case allocation
B. Next iteration(s) detailed plan and evaluation criteria
C. Elaboration phase cost/schedule performance
D. Construction phase resource plan and basis of estimate
E. Risk assessment
Demonstration Agenda
I. Evaluation criteria
II. Architecture subset summary
III. Demonstration environment summary
IV. Scripted demonstration scenarios
V. Evaluation criteria results and follow-up items
FIGURE 9-3. Default agendas for the life-cycle architecture milestone
􀀩 All open issues – like installation instructions, software version descriptions, user
and operator manuals, software support manuals, and the installation of the
development environment at the support sites – are addressed.
Software quality metrics are reviewed to determine whether quality is sufficient for
transition to the support organization.
9.1 MINOR MILESTONES
The number of iteration-specific, informal milestones needed depends on the content and
length of the iteration.
For iterations with a one-month to six-month duration: only two minor milestones – the
iteration readiness review and the iteration assessment review – are needed.
For longer iterations more intermediate review points may be necessary: test readiness
reviews , intermediate design walkthroughs , etc.
Iterations take different forms and priorities in different phases in the life-cycle.
Early iterations focus on analysis and design,
Later iterations focus more on completeness, consistency, usability, and change
management.
The milestones of an iterations and its associated evaluation criteria must focus the
engineering activities as defined in the software development plan, business case, and
vision.
􀂾 Iteration Readiness Review.
o This informal milestone is conducted at the start of each iteration.
o To review the detailed iteration plan and the evaluation criteria allocated to
the iteration.
􀂾 Iteration Assessment Review.
o This informal milestone is conducted at the end of each iteration.
o To assess the achievements of the objectives and satisfying of the evaluation
criteria by an iteration.
o To review iteration results
o To review qualification test results
o To determine the amount of rework to be done
o To review the impact of the iteration results on the plan for subsequent
iterations.
The project and the organizational culture determine the format and the content of these
informal milestones.
Assessment
Management
Requirements
Design
Implementation
Deployment
Iteration-N
Iteration N + 1
Iteration N - 1
Iteration N
initiation
Iteration
Readiness
Review
Iteration
Design
Walkthrough
Iteration
Assessment
Review
Iteration-N
Close Out
FIGURE 9-4. Typical minor milestones in the life cycle of an iteration
9.2 PERIODIC STATUS ASSESSMENTS

Risk management requires continuous attention to all interacting activities of software
development effort.
Periodic status assessments are management reviews conducted at regular intervals to
address:
􀂾 progress and quality indicators
􀂾 ensure continuous attention to project dynamics
􀂾 maintain open communications among the stakeholders.
The objective of these assessments is to ensure that the expectations of all the
stakeholders are synchronized and consistent.
Periodic status assessments act as project snapshots.
With varying periodicity, the recurring event forces the project history to be captured and
documented.
Status assessments provide:
􀃎 A mechanism for openly addressing, communicating, and resolving management
issues, technical issues, and project risks.
􀃎 Objective data derived directly from on-going activities and evolving product
configurations.
􀃎 A mechanism for disseminating process, progress, quality trends, practices, and
experience information to and from all stakeholders in an open forum.
Recurring themes from unsuccessful projects include status assessments that are
(1) high-overhead activities, because the work associated with generating the status is
separate from thee everyday work, and
(2) frequently canceled, because of higher priority issues that require resolution.
Recurring themes from successful projects include status assessments that are
(1) low-overhead activities, because the material already exists as everyday management
data, and
(2) rarely canceled, because they are considered too important.
Periodic status assessments are crucial for focusing continuous attention on the evolving
health of the project and its dynamic priories.
They force the project manager to:
􀀯 collect and review the data periodically, force outside peer review, and encourage
dissemination of best practices to and from other stakeholders.
The only content the software project manager should have to develop from scratch for
each review is an assessment of the top 10 risks.
This, also, will be predominantly an update of the previous assessment.
A good rule of thumb is that the status assessment charts should be easily produced by
the project manager within a short notice.
This will be possible when data are available within an automated environment.
The default content of periodic status assessments should include the following topics:
TOPIC CONTENT
Personnel Staffing plan vs. actuals
Attritions, additions
Financial trends Expenditure plan vs. actuals for the previous, current, and
next major milestones
Revenue forecasts
Top 10 risks Issues and criticality resolution plans
Quantification – cost, time, quality – of exposure
Technical progress Configuration baseline schedules for major milestones
Software management metrics and indicators
Current change trends
Test and quality assessments
Major milestone Plan, schedule, and risks for next major milestone
plans and results Pass/fail results for all acceptance criteria
Total product scope Total size, growth, and acceptance criteria perturbations
TABLE 9-2. Default content of status assessment reviews

1. Describe the typical sequence of life-cycle checkpoints, using a neat diagram.
[Figure 9-1/P 127]
2. Explain the different major milestones in a project life-cycle.
3. Explain the different minor milestones in a project life-cycle.
4. What is the significance of periodic assessments? Explain the contents of status
assessment reviews.
PART – III SOFTWARE MANAGEMENT DISCIPLINES Page 79 of 187
CHAPTER-10 PROJECT ORGANIZATIONS AND RESPONSIBILITIES
Project planning requires an iterative process.

Plans have an engineering stage: where the plan is developed, and a
production stage: where the plan is executed.
Plans must evolve as the understanding of the problem space and solution spaces evolve.
Planning errors must be resolved early in the life cycle to lessen their impact on the
project
success.
10.1 WORK BREAKDOWN STRUCTURES
A WBS is simply a hierarchy of elements that decomposes the project plan into the
discrete work
tasks.
A WBS provides the following information structure:
􀂾 A delineation of all significant work
􀂾 A clear task decomposition for assignment of responsibilities
􀂾 A framework for scheduling, budgeting, and expenditure tracking
Product subsystems, components, functions, organizational units, life-cycle phases,
geographies
are the parameters that drive the decomposition of work into discrete tasks.
The first-level decomposition is by subsystem.
Subsystems are decomposed into their components.
One such typical component is software.
Here we focus on the software WBS elements.
10.1.1 CONVENTIONAL WBS ISSUES
􀁣 Conventional work breakdown structures are prematurely structured around the
product
design.
A typical conventional WBS is structured primarily around the subsystems of its product
architecture, and then further decomposed into the components of each subsystem.
Once this structured is ingrained in the WBS and then allocated to responsible managers
with
budgets, schedules, and expected deliverables, a concrete planning foundation has been
set that is
difficult and expensive to change.
A WBS is the architecture for financial plan. Planning architectures also must
encapsulate
components that are likely to change.
A looser coupling between the plan and the product structure is desirable if either the
plan or
architecture is subject to change. Otherwise, a tight coupling may make sense.
􀁤 Conventional WBS structures are prematurely decomposed, planned, and budgeted in
either
too little or too much detail.
For most large-scale systems six or more levels of WBS elements are common place.
The detail doesn’t evolve with the level of fidelity in the plan when detailed plans are
prepared
right at the outset.
For example, in a project with 18-month duration, it is impossible to accurately lay down
the
details of the test activities within the first month before the architecture and test
scenarios are
engineered.
􀁥 Conventional WBSs are project-specific. Cross-project comparisons are usually
difficult or
impossible.
Individual projects define their own project-specific structure tailored to the project
manager’s
style, the customer’s demands, or other project-specific preferences.
With no standard WBS structure, it is difficult to compare plans, financial data, schedule
data,
organizational efficiencies, cost trends, productivity trends, or quality trends across
multiple
projects.
The following critical questions for process improvements programs cannot be answered
by
conventional WBS structure methods:
􀂾 Ratio of productive activities – requirements, design, implementation, assessment,
deployment to overhead activities – management, environment
􀂾 Percentage of effort expended in rework activities
􀂾 Percentage of cost expended in software capital equipment or the environment
expenditures
􀂾 Ratio of productive testing versus (unproductive) integration

􀂾 Cost of release-N as a basis for planning release-N+1
10.1.2 Evolutionary WBSs
An evolutionary WBS should organize the planning elements around the process
framework
rather than the product framework.
This approach accommodates the expected changes in the evolving plan and allows the
level of
planning fidelity to evolve in a straightforward way.
The basic recommendation for the WBS is to organize the hierarchy as follows:
Management
System requirements and design
Subsystem 1
C omponent 11
Requirements
Design
Code
Test
Documentation
… (similar structures for other components)
Component 1N
Requirements
Design
Code
Test
Documentation
… (similar structures for other subsystems)
Subsystem M
C omponent M1
Requirements
Design
Code
Test
Documentation
… (similar structures for other components)
Component MN
Requirements
Design
Code
Test
Documentation
Integration and test
Test planning
Test procedure preparation
Testing
Test reports
Other support areas
Configuration control
Quality assurance
System administration
FIGURE 10-1.
Conventional work
breakdown structure,
following the product
hierarchy
􀂾 First-level WBS elements are the workflows – management,
environment, requirements, design, implementation, assessment, and
deployment).
􀂾 These elements are allocated to a single team and constitute the anatomy
of project for planning and comparison with other projects.
A WBS consistent with the process framework – phases, workflows, and artifacts –
should show
how the elements of the process framework can be integrated into a plan.
It should provide a framework for estimating the costs and schedules of each element,
allocating
them across a project organization, and tracking expenditures.
The structure should be tailored to the specifics of a project in the following ways:
1. Scale. Larger projects will have more levels and substructures.
2. Organizational structure. Projects that span multiple organizational entities may
introduce
constraints that necessitate different WBS allocations.
3. Degree of custom development. Depending on the character of the project, there can be
different emphases in the requirements, design, and implementation workflows.
􀂾 A business process re-engineering project based primarily on existing components
would have much more depth in the requirements element and a fairly shallow design
and implementation element.
􀂾 A fully custom development of a one-of-a-kind technical application requires fairly
deep design and implementation elements to manage the risks associated with the
custom, first-generation components.
4. Business context. Contractual projects require more elaborate management and
assessment elements.
􀂾 They require more elaborate substructures for the deployment element.
􀂾 An application deployed to a single site may have a trivial deployment element or an
elaborate one.
5. Precedent experience. Most of the projects are developed as new generations of a
legacy
system or in the context of existing organizational standards rather than from the scratch.
􀂾 It is important to accommodate these constraints to ensure that new project exploit the
existing experience base and benchmarks of project performance.
The WBS decomposes the character of the project and maps it to the life cycle, the
budget, and
the personnel.
AA Inception phase management
AAA Business case development
AAB Elaboration phase release specification
AAC Elaboration phase WBS baselining
AAD Software development plan
AAE Inception phase project control and status assessments
AB Elaboration phase management
ABA Construction phase release specifications
ABB Construction phase WBS baselining
ABC Elaboration phase project control and status assessments
AC Construction phase management
ACA Deployment phase planning
ACB Deployment phase WBS baselining
ACD Construction phase project control and status assessments
A. Management
􀂾 Second-level WBS elements are the defined for each phase of the life
cycle.
􀂾 These elements allow the fidelity of the plan to evolve more naturally
with the level of understanding of the requirements and architecture,
and the risks therein.
􀂾 Third-level WBS elements are defined for the focus of activities that
produce the artifacts of each phase.
􀂾 These elements may be the lowest level in the hierarchy that collects the
cost of a discrete artifact for a given phase, or they may be decomposed
further into several lower level of activities that, taken together, produce
a single artifact.
AD Transition phase management

ADA Next generation planning
ADB Transition phase project control and status assessments
B. B . Environment BA Inception phase environment specification
BB Elaboration phase environment baselining
BBA Development environment installation and administration
BBB Dev. environment integration and custom tool-smithing
BBC SCO database formulation
BC Construction phase environment maintenance
BCA Development environment installation and administration
BCB SCO database maintenance
BD Transition phase environment maintenance
BDA Development environment maintenance and administration
BDB SCO database maintenance
BDC Maintenance environment packaging and transition
C. Requirements
CA Inception phase requirements development
CAA Vision specification
CAB Use case modeling
CB Elaboration phase requirements baselining
CBA Vision baselining
CBB Use case model baselining
CC Construction phase requirements management
CD Transition phase requirements management
D. Design
DA Inception phase architecture prototyping
DB Elaboration phase architecture baselining
DBA Architecture design modeling
DBB Design demonstration planning and conduct
DBC Software architecture description
DC Construction phase design modeling
DCA Architecture design model maintenance
DCB Component design modeling
DD Transition phase design maintenance
E. Implementation
EA Inception phase component prototyping
EB Elaboration phase component implementation
EBA Critical component coding demonstration integration
EC Construction phase component implementation
ECA Initial release(s) component coding and stand-alone testing
ECB Alpha release component coding and stand-alone testing
ECC Beta release component coding and stand-alone testing
ECD Component maintenance
ED Transition phase component maintenance
Reviewing a WBS provides insight into the important attributes, priorities, and structure
of the
project plan.
WBS is the most valuable source of objective information about the project plan in
performing
project assessments and software management audits.
G. Deployment
GA Inception phase deployment planning
GB Elaboration phase deployment planning
GC Construction phase deployment
GCA User manual baselining
GD Transition phase deployment
GDA Product transition to user
FIGURE 10-2. Default work breakdown structure
F. Assessment
FB Elaboration phase assessment
FA Inception phase assessment planning
FBA Test modeling
FBB Architecture test scenario implementation
FBC Demonstration assessment and release descriptions
FC Construction phase assessment
FCA Initial release assessment and release description
FCB Alpha release assessment and release description
FCC Beta release assessment and release description
FD Transition phase requirements management
FDA Product release assessment and release descriptions
WBS element Fidelity
Management High
Environment Moderate
Requirements High
Design Moderate
Implementation Low
Assessment Low
Deployment Low
Management High
Environment High
Requirements High
Design High
Implementation Moderate
Assessment Moderate
Deployment Low
Management High
Environment High
Requirements Low
Design Low
Implementation Moderate
Assessment High
Deployment High
Management High
Environment High
Requirements Low
Design Moderate
Implementation High
Assessment High
Deployment Moderate
FIGURE 10-3. Evolution of planning fidelity in the WBS over the life cycle
Inception Elaboration
Transition Construction
Software development plan and the business case provide a context for review, the WBS
and the
relative budgets of the elements provide the indicators of the management approach,
priorities,
and concerns.
Another important attribute of a good WBS is that the planning fidelity inherent in each
element
is commensurate with the current life-cycle phase and project state.
Another important attribute of a good WBS is that the planning fidelity inherent in each
element
is commensurate with the current life-cycle phase and project state.
This idea is illustrated in the above figure.
The above method allows for planning elements that range from planning packages
through fully
planned activity networks.
10.2 PLANNING GUIDELINES
Software projects span a broad range of application domains.
Making specific planning recommendations is risky when made independent of context.
At the same time, it is valuable, also, as most people look for a starting point, a skeleton
to flesh
out with project-specific details.
Initial planning guidelines capture the expertise and experience of many other people.
Such guidelines are therefore considered credible bases of estimates and instill some
confidence
in the stakeholders.
Project-independent planning advice is also risky.
The risk is that the guidelines may be adopted blindly without being adapted to specific
project
circumstances.
This may lead to an incompetent management team.
Another risk is that of misinterpretation.
The variability of project parameters, project business contexts, organizational cultures,
and
project processes makes it extremely easy to make mistakes that have significant
potential
impact.
Two simple planning guidelines should be considered when a project plan is being
initiated or
assessed.
The details of the first guideline : The details of the second guideline:
Given an initial estimate of total project cost and these two tables, developing a staffing
profile,
an allocation of staff resources to teams, a top-level schedule, and an initial WBS with
task
budgets and schedules is relatively straight forward.
The data in Table 10-1 and Table 10-2 come mostly from software cost estimation
efforts.
TABLE 10-1.
WBS budgeting defaults
FIRST-LEVEL
WBS ELEMENT
DEFAULT
BUDGET
Management 10%
Environment 10%
Requirements 10%
Design 15%
Implementation 25%
Assessment 25%
Deployment 5%
Total 100%
TABLE 10-2.
Default distributions of effort and schedule by phase
DOMAIN INCEPTION
ELABORATION
CONSTRUCTION
TRANSITION
Effort 5% 20% 65% 10%
Schedule 10% 30% 50% 10%
The default allocations for budgeted costs, given in table 10-1, vary across projects. It
provides a
good benchmark for assessing the plan by understanding the rationale for deviations from
these
guidelines.
The entries in the table 10-1 are cost allocations and not effort allocations.
The difference between the two arises because of:
1.The cost of labor is inherent in these numbers.
For example, the management, requirements, and design elements tend to use more
personnel
who are senior and more highly paid than other element use.
That is why the cost for these two elements is 25%. It doesn’t mean the number of people
also will be required in that proportion.
2.The cost of hardware and software assets that support the process automation and
development teams is also included in the environment element.
Table 10-2 provided guidelines for allocating effort and schedule across the life-cycle
phases.
These values provide an average expectation across a spectrum of application domains.
10.3 THE COST AND SCHEDULE ESTIMATING PROCESS
Project plans need to be derived from two perspectives:
First, a forward-looking, top-down approach:
It starts with an understanding of the general requirements and constraints, derives a
macro-level
budget and schedule, then decomposes these elements into lower level budgets and
intermediate
milestones.
From this perspective, the following planning sequence occurs:
1. The software project manager develops a characterization of the overall size,
process, environment, people and quality required for the project.
2. A macro-level estimate of the total effort and schedule is developed using a
software cost estimation model.
3. the software project manager partitions the estimate for the effort into a top-level
WBS.
The project manager also partitions the schedule into major milestone dates and
partitions the effort into a staffing profile.
These types of estimates tend to ignore many detailed project-specific parameters.
4. At this point, subproject managers are given the responsibility for decomposing
each of the WBS elements into lower levels using their top-level allocation, staffing
profile, and major milestone dates as constraints.
Second, a backward-looking, bottom-up approach:
Keeping the end in mind, the micro-level budgets and schedules are analyzed and then
they are
all summed into the higher level budgets and intermediate milestones.
This approach tends to define and populate the WBS from the lowest levels upward.
From this perspective the planning sequence is:
1. The lowest level WBS elements are elaborated into detailed tasks, for which budgets
and
schedules are estimated by the responsible WBS element manager.
These estimates tend to incorporate the project-specific parameters in an exaggerated
way.
2. Estimates are combined and integrated into higher level budgets and milestones.
The biases of individual estimators need to be homogenized so that there is a consistent
basis of negotiation.
3. Comparisons are made with the top-down budgets and schedule milestones.
Gross differences are assessed and adjustments are made in order to converge on
agreement between the top-down and bottom-up estimates.
Milestone scheduling or budget allocation using top-down estimating tends to exaggerate
the
project management biases and results in an overly optimistic plan.
Bottom-up estimates exaggerate the performer biases and result in an overly pessimistic
plan.
Iteration is necessary, using the results of one approach to validate and refine the results
of the
other approach, thereby evolving the plan through multiple versions.
This process instills ownership of the plan in all levels of management.
These two planning approaches should be used together, in balance, throughout the life
cycle of
the project.
During the engineering stage, the top-down perspective will dominate as there is usually
not
enough depth of understanding or stability in the detailed task sequences to perform
credible
bottom-up planning.
During the production stage, there should be enough precedent experience and planning
fidelity
that the bottom-up planning perspective will dominate.
By then, the top-down approach should be well tuned to the project-specific parameters,
so it
should be used more as a global assessment technique.
Figure 10-4 illustrates this life-cycle planning balance.
10.4 THE ITERATION PLANNING PROCESS
In addition to the application-independent aspects of budgeting and scheduling, another
dimension of planning concerns with defining the actual sequence of intermediate results.
Planning the content and schedule of the major milestones and their intermediate
iterations is the
most tangible form of the overall risk management plan.
An evolutionary build plan is important as there are always adjustments in build content
and
schedule as early conjecture evolves into well-understood project circumstances.
A description of a generic build progression and general guidelines on the number of
iterations in
each phase:
Engineering stage Production stage
Feasibility
iterations
Architecture
iterations
Usable iterations Product releases
100%
Bottom-up task-level planning based
on metrics from previous iterations
Top-down project-level planning based
on macro-analysis on previous projects
Engineering stage planning emphasis:
􀃠 Macro-level task estimation for
production-stage artifacts
􀃠 Micro-level task estimation for
engineering artifacts
􀃠 Stakeholder concurrence
􀃠 Coarse-grained variance analysis of
actual vs. planned expenditures
􀃠 Turning the top-down projectindependent
planning guidelines
into project-specific planning
guidelines
􀃠 WBS definition and elaboration
Production stage planning emphasis:
􀃠 Micro-level task estimation for
production-stage artifacts
􀃠 Macro-level task estimation for
maintenance of engineering
artifacts
􀃠 Stakeholder concurrence
􀃠 Fine-grained variance analysis of
actual vs. planned expenditures
FIGURE 10-4.
Planning balance throughout life cycle
Iteration is used to mean a complete synchronization across the project, with a well-
orchestrated
global assessment of the entire project baseline.
Other micro-operations – monthly, weekly or daily builds – are performed en route to
these
project-level synchronization points.
􀁺 Inception iterations.
􀀶 The early prototyping activities integrate the foundation components of a candidate
architecture and provide an executable framework for elaborating critical use cases of
the system.
􀀶 This framework includes existing components, commercial components, and custom
prototypes sufficient to demonstrate a candidate architecture and sufficient
requirements understanding to establish a credible business case, vision, and software
development plan.
􀀶 To achieve an acceptable prototype, two iterations may be necessary based on the size
of the project.
􀁺 Elaboration iterations.
􀀶 These iterations result in an architecture, including a complete framework and
infrastructure for execution.
􀀶 Upon completion of the architecture iteration, a few critical use case should be
demonstrable:
(1) initializing the architecture,
(2) injecting a scenario to drive the worst-case data processing flow through the
system – for example, the peak load scenario, and
(3) injecting a scenario to drive the worst-case control flow through the system – for
example, orchestrating the fault-tolerance use cases.
􀀶 Two iterations should be planned for, to achieve an acceptable architectural baseline.
􀀶 More iterations may be required in exceptional cases.
􀁺 Construction iterations.
􀀶 Most projects require at least two major construction iterations:
(1) An alpha release includes executable capability for all the critical use cases.
It represents about 70% of the total product breadth and performs at quality –
performance and reliability – levels below the final expectations.
(2) A beta release provides 95% of the total product capability breadth and achieves
some the important attributes.
􀀶 A few more features need to be completed, and improvements in robustness and
performance are necessary for the final product release to be acceptable.
􀀶 To manage risks or optimize resource consumption, a few more iterations may be
necessary, in some cases.
􀁺 Transition iterations.
􀀶 Most projects use a single iteration to transition a beta release into the final product.
􀀶 A number of small-scale iterations may be necessary to resolve defects, incorporate
beta feedback, and incorporate performance improvements.
􀀶 Because of the overhead associated with a full-scale transition to the user community,
most projects do away with a single iteration between a beta release and the final
product release.
A typical project would have the following six-iteration profile :
o One iteration in inception: an architecture prototype
o Two iterations in elaboration: architecture prototype and
architecture baseline
o Two iterations in construction: alpha and beta releases
o One iteration in transition: product release
The resulting management overhead may be well worth the cost to ensure proper risk
management and stakeholder synchronization.
10.5 PRAGMATIC PLANNING
Good planning is more dynamic in an iterative process. Doing it accurately is also far
easier.
The software project manager, while executing iteration N of any phase must:
(1) monitor and control against a plan initiated in iteration N-1, and
(2) plan iteration N+1.
Making good trade-offs in the current iteration plan and next iteration plan based on
objective
results in the current iteration and previous iterations, is a good management practice.
In addition to bad architectures and misunderstood requirements, inadequate planning is
one of
the most common reasons for project failures.
The success of every successful project can be attributed in part to good planning.
Plans are not just for managers.
The more open and visible the panning process and results, the more ownership there is
among
the team members who need to execute it.
Bad, closely held plans cause attrition.
Good, open plans shape cultures and encourage teamwork.
1. Define a WBS. Compare the issues related to the conventional and evolutionary
WBSs.
2. Explain the two planning guidelines.
3. Explain how planning balance is achieved throughout the life cycle in cost and
schedule
estimating process.
4. Explain the iteration planning process in the four phases of the life cycle.
Software lines of business are motivated by return on investment, new business

discriminators, market diversification, and profitability.
Project teams are motivated by the cost, schedule, and quality of specific deliverables.
Software professionals, in both types of organizations, are motivated by career growth,
job satisfaction, and the opportunity to make a difference.
Project rarely invest in any technology or service that doesn’t directly impact the cost,
schedule, or quality of the deliverables.
The organizations focused on the project – the level where software is developed and
delivered.
Generic roles, relationships, and responsibilities are described in this chapter for both line
of business and project types of software organizations.
The ideas or recommendations presented here have to be tailored to the domain, scale,
cultures, and personalities of a specific situation.
11.1 LINE-OF-BUSINESS ORGANIZATIONS
Figure 11-1 maps roles and responsibilities to a default line-of-business organization.
The main features of the default organization are:
􀂾 Responsibility for process definition and maintenance is specific to a cohesive line of
business, where process commonality makes sense.
􀀶 For example: the process for developing avionics software is different from
that of developing office applications.
􀂾 Responsibility for process automation is an organizational role and is equal in
importance to the process definition role.
􀀶 Projects achieve process commonality through the environment support of
common tools.
􀂾 Organizational roles are fulfilled by a single individual or several different teams,
depending on the scale of the organization.
􀂔 A 20-person software product company may require only a single person
to fulfill all the roles, while a 10,000-person company may require hundreds
of people to achieve an effective software organization.
Organization
Manager
Software Engineering
Process Authority
Project Review
Authority
Software Engineering
Environment Authority
Infrastructure
􀀶 Process definition
􀀶 Process improvement
􀀶 Process compliance
􀀶 Periodic risk assessment
􀀶 Process automation 􀀶 Project administration
􀀶 Engineering skill centers
􀀶 Professional development
Project A
Manager
Project B
Manager
Project C
Manager
Project D
Manager
Project N
Manager
FIGURE 11-1. Default
roles in a software line-ofbusiness
organization
Software Engineering Process Authority < SEPA >

􀂔 SEPA facilitates the exchange of information and process guidance both to and
from project practitioners.
􀂔 This role is accountable to the general manager for maintaining current assessments
of the process maturity and the plan for future process improvements.
􀂔 The SEPA must help initiate and periodically assess project processes.
􀂔 Only when the SEPA understands both the desired improvement and the project
context, it will be possible to catalyze the capture and dissemination of best
software practices.
􀂔 The SEPA is a necessary role in any organization to take on the responsibility and
accountability for the process definition and its modification, improvement, or
technology insertion.
􀂔 The SEPA could be a single individual – the general manager, or a team of
representatives.
􀂔 The SEPA must be an authority, competent and powerful, not a staff position
rendered impotent by ineffective bureaucracy.
Project Review Authority < PRA >
􀂔 The PRA is responsible for ensuing that a software project complies with all
organizational and business unit software policies, practices, and standards.
􀂔 A software project manager is responsible for meeting the requirements of a
contract or any other compliance standard, and is accountable to the PRA.
􀂔 The PRA reviews both the project’s conformance to contractual obligations and the
project’s organizational policy obligations.
􀂔 The customer monitors contract requirements, contract milestones, contract
deliverables, monthly management reviews, progress, quality, cost, schedule, and
risk.
􀂔 The PRA reviews customer commitments and adherence to organizational policies,
organizational deliverables, financial performance, and other risks and
accomplishments.
Software Engineering Environment Authority < SEEA >
􀂔 The SEEA is responsible for automating the organization’s process, maintaining the
organization’s standard environment, training projects to use the environment, and
maintaining organization-wise reusable assets.
􀂔 The SEEA role is necessary to achieve a significant return on investment for a
common process.
􀂔 Tools, techniques, and training can be amortized (repaid) effectively across multiple
projects only if someone like the SEEA is responsible for supporting and
administering a standard environment.
􀂔 In many cases, the environment may be augmented, customized, or modified, but
the existence of an 80% default solution for each project is critical to achieving
institutionalization of the organization’s process and a good ROI on capital tool
investments.
Infrastructure
􀂔 An organization’s infrastructure provides human resources support, projectindependent
research and development, and other capital software engineering
assets.
􀂔 The infrastructure can range from trivial to highly entrenched bureaucracies.

􀂔 The typical components of the organizational infrastructure are:
􀂾 Project administration: time accounting system; contracts, pricing, terms
and conditions; corporate information
􀂾 Engineering skill centers: custom tools repository and maintenance, bid
and proposal support, independent research and development
􀂾 Professional development: internal training boot camp, personnel
recruiting, personnel skills database maintenance, literature and assets
library, technical publications
􀂔 An organizational service center promotes a standard environment when maintained
as a capital asset for projects within the organization.
􀂔 The SEEA is a companion group to the SEPA.
􀂔 The SEPA is responsible for process definition and improvement, and the SEEA for
process automation.
Software development environments must be treated as capital equipment, just like the
hardware is treated.
For mature organizations the process and tooling are treated as project expenses as they
are treated as organizational assets. They should be funded with capital resources.
Financing models can include absorption into overhead or general and administrative
costs, or project billing based on usage.
11.2 PROJECT ORGANIZATIONS
Figure 11-2 shows a default project organization and maps project-level roles and
responsibilities.
Software Management
Systems Engineering
Administration
Software Assessment
Software Architecture
Software Development
Artifacts:
􀂂 Business case
􀂂 Software development plan
􀂂 Status assessments
Activities:
􀂂 Customer/PRA interface
􀂂 Planning/progress monitoring
􀂂 Risk management
􀂂 Software process definition
􀂂 Process improvement
Artifacts:
􀂂 Vision statement
􀂂 Requirements set
Activities:
􀂂 Requirements elicitation
􀂂 Requirements specification
􀂂 Use case modeling
Artifacts:
􀂂 Work breakdown structure
Activities:
􀂂 Financial forecasting, reporting
􀂂 WBS definition, administration
Artifacts:
􀂂 Architecture description
􀂂 Release specifications
􀂂 Design set
Artifacts:
􀂂 Design set
􀂂 Implementation set
􀂂 Requirements set
􀂂 Deployment set
Artifacts:
􀂂 Deployment set
􀂂 SCO database
􀂂 User manual
􀂂 Release descriptions
􀂂 Environment
􀂂 Deployment documents
Activities:
􀂂 Release assessment
􀂂 Use case/scenario testing
􀂂 Test scenario development
􀂂 Change management
􀂂 System administration
􀂂 Environment configuration
􀂂 Environment maintenance
􀂂 Tool-smithing
Activities:
􀂂 Component design
􀂂 Component implementation
􀂂 Component testing
􀂂 Component maintenance
Activities:
􀂂 Demonstration planning
􀂂 Analysis, design
􀂂 Architecture prototyping
􀂂 Architecture documenting
􀂂 Demonstration coordination
􀂂 Component design
􀂂 Make/buy/reuse analysis
FIGURE 11-2.
Project organization and
responsibilities
The main features of the default organization are as follows:

􀂍 The project management team is an active participant, responsible for producing
as well as managing.
Project management is not a spectator.
􀂍 The architecture team is responsible for real artifacts and for the integration of
components, not just for staff functions.
􀂍 The development team owns the component construction and maintenance
activities.
The assessment team is separate from development.
This structure fosters as independent quality perspective and focuses a team on
testing and product evaluation activities concurrent with development.
􀂍 Quality is everyone’s job, integrated into all activities and checkpoints,.
Each team takes responsibility for a different quality perspective.
Software Management Team
Schedules, costs, functionality, and quality expectations are highly interrelated. They
require continuous negotiation among the stakeholders who have different goals.
The software management team is expected to deliver win conditions to all stakeholders.
So, the software manager has the burdensome task of balance.
The focus of software management team activities over the project life cycle:
The software management team management is responsible for
􀂾 planning the effort,
􀂾 conducting the plan, and
􀂾 adapting the plan to changes in the understanding of the requirements or the design.
For this, the team takes ownership of resource management and project scope, and sets
operational priorities across the life cycle.
At an abstract level, these activities correspond to managing the expectations of all
stakeholders.
The software management team takes ownership of all aspects of quality.
It is responsible for attaining and maintaining a balance among the aspects so that the
overall solution is adequate and optimal.
Software Architecture Team
The software architecture team is responsible for the architecture.
Systems s engineering
Financial Administration
Quality assurance
Life-Cycle Focus
Inception elaboration Construction Transition
Elaboration phase
planning
Team formulation
Contracts baselining
Architecture costs
Construction phase
planning
Full staff recruitment
Risk resolution
Product acceptance
criteria
Construction costs
Transition phase
planning
Construction plan
optimization
Risk management
Customer satisfaction
Contract closure
Sales support
Next-generation planning
Software Management
Artifacts:
􀂍 Business case
􀂍 Vision
􀂍 Software development plan
􀂍 WBS
􀂍 Status assessments
􀂍 Requirements set
Responsibilities:
􀂍 Resource commitments
􀂍 Personnel assignments
􀂍 Plans, priorities
􀂍 Stakeholder satisfaction
􀂍 Scope definition
􀂍 Risk management
􀂍 Project control
FIGURE 11-3. Software management team activities
This encompasses the engineering necessary to

􀂾 specify a complete bill of materials for the software, and
􀂾 make significant make/buy trade-offs so that all custom components are elaborated to
the extent that construction/assembly costs are highly predictable.
The focus of software architecture team over the life cycle is:
For any project, the skill of the software architecture team is crucial.
It provides the framework for facilitating communications, for achieving system-wide
quality, and for implementing the applications.
The success of the team depends on the quality of the architecture team. A good team
ensures success. A bad team with an expert team also, the project fails.
The inception and elaboration phases are dominated by two distinct teams: the software
management team and software architecture team.
The software development and software assessment teams engage in support roles in the
production stage.
By the construction phase, the architecture transitions into a maintenance mode and must
be supported by a minimal level of effort to ensure continuity of the engineering legacy.
The architecture team must include the following level of expertise:
􀂾 Domain experience to produce an acceptable design view and use case view
􀂾 Software technology experience to produce an acceptable process view, component
view, and deployment view
The architecture team is responsible for system-level quality, which includes attributes
such as reliability, performance, and maintainability.
These attributes span multiple components and represent how well the components
integrate to provide an effective solution.
So, the architecture team decides how multiple-component design issues are resolved.
Software Development Team
The figure on the next page shows the software development team activities over the
lifecycle:
The software development team is the most application-specific group.
It comprises several sub-teams dedicated to groups of components that require a common
skill set.
Typical skill sets include:
􀂾 Commercial component:
Specialists with detailed knowledge of commercial components central to the
architecture
Demonstrations
Use case modelers
Design modelers
Performance analysts
Life-Cycle Focus
Architecture prototyping
Make/buy trade-offs
Primary scenario
definition
Architecture evaluation
criteria definition
Architecture baselining
Primary scenario
demonstration
Make/buy trade-off
baselining
Architecture
maintenance
Multiple-component
issue resolution
Performance tuning
Quality improvements
Architecture
maintenance
Multiple-component
issue resolution
Performance tuning
Quality improvements
Software Architecture
Artifacts:
􀂛 Architecture prototyping
􀂛 Make/buy trade-offs
􀂛 Primary scenario
definition
􀂛 Architecture evaluation
criteria definition
Responsibilities:
􀂛 Requirements trade-offs
􀂛 Design trade-offs
􀂛 Component selection
􀂛 Initial integration
􀂛 Technical risk resolution
FIGURE 11-4. Software architecture team activities
􀂾 Database:
Specialists with experience in the organization, storage, and retrieval of data
􀂾 GUI:
Specialists with experience in the display organization, data presentation, and user
interaction to support human input, output, and control needs
􀂾 Operating systems and networking:
Specialists with experience in the execution of multiple software objects on a network
of hardware resources, including all the control issues associated with initialization,
synchronization, resource sharing, name space management, reconfiguration,
termination, and inter-object communications
􀂾 Domain applications:
Specialists with experience in algorithms, application processing, or business rules
specific to the system
The software development team is responsible for the quality of individual components,
including all component development, testing, and maintenance.
The development team decides how nay design or implementation issue local to a single
component is resolved.
Software Assessment Team
There are two reasons for using an independent team for software assessment:
(1) to ensure an independent quality perspective.
(2) to exploit the concurrency of activities
Schedules can be accelerated by developing software and preparing for testing in parallel
with development activities.
Change management, test planning, and test scenario development can be performed in
parallel with design and development.
A modern process should employ use-case-oriented or capability-based testing organized
as a sequence of builds and mechanized via two artifacts:
1. release specification – the plan and evaluation criteria for a release
2. release description – the results of a release
Component teams
Life-Cycle Focus
Prototyping support
Make/buy trade-offs
Critical component design
Critical component
implementation and test
Critical component
baseline
Component design
Component
implementation
Component stand-alone
test
Component maintenance
Component maintenance
Component
documentation
Software Development
Responsibilities:
􀀶 Component design
􀀶 Component implementation
􀀶 Component stand-along test
􀀶 Component maintenance
􀀶 Component documentation
Artifacts:
􀀶 Design set
􀀶 Implementation set
􀀶 Deployment set
FIGURE 11-5. Software development team activities
The following figure shows the focus of software assessment team activities over the life
cycle:
Each release may encompass several components, because integration proceeds
continuously.
Evaluation criteria will document the customer’s expectations at each major milestone,
and release descriptions will substantiate the test results.
The final iterations will be equivalent to acceptance testing and include levels of detail
similar to the levels of detail of software test plans, procedures, and reports.
The artifacts evolve from brief, abstract versions in early iterations into more detailed and
more rigorous documents, with detailed completeness and traceability discussions in later
releases.
These scenarios should be subjected to change management like other software and are
always maintained up-to-date for automated regression testing.
The assessment team is responsible for the quality of baseline releases with respect to the
requirements and customer expectations.
The assessment team is therefore responsible for exposing any quality issues that affect
the customer’s expectations, whether or not the expectations are captured in the
requirements.
11.3 EVOLUTION OF ORGANIZATIONS
The project organization represents the architecture of the team and needs to evolve
consistent with the project plan captured in the WBS.
The following figure illustrate how the team’s center of gravity shifts over the life cycle,
with about 50% of the staff assigned to one set of activities in each phase:
Release testing
Change management
Deployment
Environment support
Life-Cycle Focus
Infrastructure planning
Primary scenario
prototyping
Infrastructure baseline
Architecture release testing
Change management
Initial user manual
Infrastructure upgrades
Release testing
Change management
User manual baseline
Requirements
verification
Infrastructure
maintenance
Release baseline
Change management
Deployment to users
Requirements verficiation
Software Assessment
Responsibilities:
􀀈 Project infrastructure
􀀈 Independent testing
􀀈 Requirements
verification
􀀈 Metrics analysis
􀀈 Configuration control
􀀈 Change management
􀀈 User deployment
Artifacts:
􀀈 Deployment set
􀀈 SCO database
􀀈 User manual
􀀈 Environment
􀀈 Release specifications
􀀈 Release descriptions
􀀈 Deployment
documents
FIGURE 11-6. Software assessment team activities
A different set of activities is emphasized in each phase, as follows:

♥ Inception team
Focus on planning, with enough support from other teams to ensure that the plans
represent a consensus of all perspectives
♥ Elaboration team
Focus on architecture in which the driving forces of the project reside in the software
architecture team and are supported by the software development and software
assessment teams to achieve a stable architecture baseline
♥ Construction team
Most of the activity resides, in a balanced way, in the software development and
software assessment teams
♥ Transition team
Customer-focused with usage feedback driving the deployment activities
1. Explain the two types of project organizations including their characteristics,
responsibilities, and roles.
2. Explain the features of the Line-of-Business organizations.
3. Explain the features of the project organizations.
4. Using a neat diagram, explain the evolution of project organizations over the life
cycle.
Software management
10%
Software architecture
5%
35%
Software Assessment
50%
Software
management
10%
50%
Software
development
20%
Software Assessment
10%
Software management
50%
20%
Software
development
20%
Software Assessment
10%
Software management
10%
10%
50%
Software Assessment
30%
Construction
Inception Elaboration
Transition
PART – III SOFTWARE MANAGEMENT DISCIPLINE Page 97 of 187
CHAPTER-12 PROCESS AUTOMATION
In addition to process definition and tailoring, a significant level of process automation is
also necessary for software development to operate profitably.
Automation requirements grow depending on the scale of the effort.
The techniques, training, time scales, acceptance criteria, and levels of automation differ
significantly between small projects and large scale, multiple-organization, catastrophic
cost-of-failure applications.
The task of integrating the environment and infrastructure for software development
results in the selection of incompatible tools that have different information repositories,
are supplied by different vendors, work on different platforms, use different jargon, and
are based on different process assumptions.
Integrating such an infrastructure is unexpectedly very complex.
Automating the development process and establishing an infrastructure for supporting
various projects workflows are important activities of the engineering stage of the life
cycle.
They include the tool selection, custom tool-smithing, and process automation necessary
to perform against the development plan with acceptable efficiency.
Evolving the development environment into maintenance environment is also crucial.
The top-level WBS recognizes the environment as a first-class workflow.
Each of the three levels of the process requires a certain degree of process automation for
the corresponding process to be carried out efficiently:
1. Metaprocess.
􀂌 An organization’s policies, procedures, and practices for managing a softwareintensive
line of business.
􀂌 The automation support for this level is called an infrastructure.
􀂌 An infrastructure is an inventory of preferred tools, artifact templates,
microprocess guidelines, macroprocess guidelines, project performance
repository, database of organizational skill sets, and library of precedent
examples of past project plans and results.
2. Macroprocess.
􀂌 A project’s policies, procedures, and practices for producing a complete
software product within their cost, schedule, and quality constraints
􀂌 The automation support for a project’s process is called an environment.
􀂌 An environment is a specific collection of tools to produce a specific set of
artifacts as governed by a specific project plan.
3. Microprocess.
􀂌 A project team’s policies, procedures, and practices for achieving an artifact of
the software process.
􀂌 The automation support for generating an artifact is called a tool.
􀂌 Tools include requirements management, visual modeling, compilers, editors,
debuggers, change management, metrics automation, document automation, test
automation, cost estimation, and workflow automation.
While the main focus of process automation is the workflow of a project-level
environment, the infrastructure context of the project’s parent organization and the tool
building blocks are the prerequisites.
12.1 TOOLS: AUTOMATION BUILDING BLOCKS
There are many tools available to automate the software development process.
Most of the core software development tools map closely to one of the process
workflows,
as illustrated in the following figure:
Each of the process workflows has a distinct need for automation support.
In some cases, it is necessary to generate an artifact; in others, it is needed for
bookkeeping.
Critical concerns associated with each workflow are:
Management
There are many opportunities for automating the project planning and control activities of
the management workflow.
􀂾 Software cost estimation tools and WBS tools are useful for generating the planning
artifacts.
􀂾 For managing against a plan, workflow management tools and a software project
control panel that can maintain an on-line version of the status assessments are
advantageous.
This automation support can improve the insight of the metrics collection and reporting
concepts.
Environment
Configuration management and version control are essential in a modern iterative
The metrics approach is dependent on measuring changes in software artifact baselines.
The environment must support the change management automation.
Requirements
Conventional approaches decomposed
􀂌 system requirements into subsystem requirements,
􀂌 subsystem requirements into component requirements, and
􀂌 component requirements into unit requirements
The equal treatment of all requirements wasted time on non-driving requirements, and
also on the corresponding paper work that was ultimately discarded.
In a modern process,
♥ The requirements are captured in the vision statement.
Workflows Environment Tools and Process Automation
Construction Inception Construction Transition
Management Workflow automation, metrics automation
Environment Change management, document automation
Requirements Requirements management
Design Visual modeling
Implementation Editor, compiler, debugger
Assessment Test automation, defect tracking
Deployment Defect tracking
FIGURE 12-1. Automation and tool components that support the process workflows
♥ Lower levels requirements are driven by the process – organized by iteration in stead of
by lower level component – in the form of evaluation criteria.
♥ The vision statement captures the contract between the development group and the
customer.
♥ This information should be evolving but slowly varying, across the life cycle, and
should be represented in customer-understanding form.
♥ The evaluation criteria are captured in the release specification artifacts, which are
transient snapshots of objectives for a given iteration.
♥ Evaluation criteria are derived from the vision statement plus other sources like
make/buy analyses, risk management concerns, architectural considerations,
implementation constraints, quality thresholds, etc.
Iterative models allow the customer and the developer to work with tangible, evolving
versions of the system.
Pragmatically, requirements must evolve along with an architecture and an evolving set
of application increments.
In stead of focusing on consistency, completeness, and traceability of immature
requirements specifications, projects need to focus on achieving the proper specification
of the vision and to evolve the lower level specifications through successive sets of
evaluation criteria against the evolving design iterations.
The consequences of this approach on the environment’s support for requirements
management are twofold:
(1) The recommended requirements approach is dependent on both textual and
model-based representations.
So, the environment should provide integrated doc automation and visual
modeling for capturing textual specifications and use case models.
It is necessary to manage and track changes to either format and present them in
human-readable format – electronic or paper-based.
(2) Traceability between requirements and other artifacts needs to be automated
The requirements set artifacts need a well-defined traceability to test artifacts as
the overall assessment team is responsible for demonstrating the product’s level
of compliance with the requirements.
The problem space description – given in the requirements set, and the solution
space description – represented in the other technical artifact sets, has traceability
between the requirements and the design, the architecture is likely to evolve in a
way that optimizes requirements traceability rather than design integrity.
This effect is more pronounced if tools are used to automate the process.
Design
The tools that support the requirements, design, implementation, and assessment
workflows are all used together.
The less separable they are, the better.
The primary support required for the design workflow is visual modeling, which is used
for capturing design models, presenting them in human-readable format, and translating
them into source code.
An architecture-first and demonstration-based process is enabled by existing architecture
components and middleware.
Implementation
The implementation workflow relies on a programming environment – editor, compiler,
debugger, linker, runtime.
It should also include substantial integration with the change management tools, visual
modeling tools, and test automation tools to support productive iteration.
Assessment and Deployment
The assessment workflow requires some more additional tools to support test automation
and test management.
To increase change freedom, testing and document production must be automated.
Defect tracking is another important tool that supports assessment: It provides the change
management instrumentation to automate metrics and control release baselines.
It is also needed to support the deployment workflow throughout the life cycle.
12.2 THE PROJECT ENVIRONMENT

The project environment artifacts evolve through three discrete states:
1. the prototyping environment, 2. the development environment, and 3. the maintenance
environment.
1. The prototyping environment
It includes an architecture test-bed for prototyping project architectures to
evaluate trade-offs during the inception and elaboration phases.
This informal configuration of tools should be capable of supporting the
following activities:
􀀩 Performance trade-offs and technical risk analyses
􀀩 Make/buy trade-offs and feasibility studies for commercial products
􀀩 Fault tolerance/dynamic reconfiguration trade-offs
􀀩 Analysis of the risks associated with transitioning to full-scale implementation
􀀩 Development of test scenarios, tools, and instrumentation suitable for
analyzing requirements
2. The development environment
It includes a full suite of development tools to support the various process
workflows and to support round-trip engineering to the maximum extent possible.
3. The maintenance environment
It should coincide with a mature version of the development environment.
The maintenance environment may be a subset of the development environment
delivered as one of the project’s end products.
A highly integrated environment is necessary both to facilitate and to enforce
management control of the process.
For this, there are four important environment disciplines that are critical to the
management context and the success of a modern iterative development process:
1. Tools must be integrated to maintain consistency and traceability.
Round-engineering is the term used to describe this key requirement for
environments that support iterative development.
2. Change management must be automated and enforced to manage multiple
iterations and to enable change freedom.
Change is the fundamental primitive of iterative development.
3. Organizational infrastructures enable project environments to be derived from a
common base of processes and tools.
A common infrastructure promoted inter-project consistency, reuse of training,
reuse of experience, and other strategic improvements to the metaprocess.
4. Extending automation support for the stakeholder environments enables further
support for paperless exchange of information and more effective review of
engineering artifacts.
12.2.1 ROUND-TRIP ENGINEERING
To maintain different information sets for the engineering artifacts, more automation
support is needed to ensure efficient and error-free transition of data from one artifact to
another.
Round-trip engineering is the environment support necessary to maintain consistency
among the engineering artifacts. The following figure depicts important transitions
between information repositories:
In the above figure, the automated translation of design models to source code – both
forward and reverse engineering – is well established.
The automated translation of design models to process/distribution models is also
straightforward through technologies like Active X and Common Object Request Broker
Architecture (CORBA).
Compilers and linker provide automation of source code into executable code.
As architectures use heterogeneous components, platforms, and languages, the
complexity of building, controlling, and maintaining large-scale webs of components
introduces new needs for configuration control and automation of build management.
The primary reason for round-trip engineering is to allow freedom in changing software
engineering data sources.
This configuration control of all the technical artifacts is crucial to maintaining a
consistent and error-free representation of the evolving product.
It is not always necessary to have bi-directional transitions in all cases.
Translation from one data source to another may not provide 100% completeness. For
example, translating design models into C++ source code may provide only the structural
and declarative aspects of the source code representation.
The code components may still need to be fleshed out with the specifics of certain object
attributes and methods.
12.2.2 Change Management
Change management is as critical to iterative processes as planning.
Tacking changes in the technical artifacts is crucial to understanding the true technical
progress trends and quality trends toward delivering an acceptable end product or interim
release.
Forward engineering (source generation from models)
Reverse engineering (models generation from source)
Deployment Set
Executable Code
Design Set
UML Models
Implementation set
Source Code
Requirement Set
UML Models
Automated build management
Automated distribution links
Portability among platforms and network topologies
FIGURE 12-2. Round-trip engineering
Automated
production
Traceability
links
In conventional software management processes, baseline configuration management

techniques for technical artifacts were predominantly a late life-cycle activity.
In a modern process change management has become fundamental to all phases and
almost all activities.
Software Change Orders
The atomic unit of software work that is authorized to create, modify, or obsolesce
components within a configuration baseline is called a software change order (SCO).
SCOs are a key mechanism for partitioning, allocating, and scheduling software work
against an established software baseline and for assessing progress and quality.
An example SCO, as a good starting point for describing a set of change primitives:
It shows the level of detail required to achieve the metrics and change management rigor.
By automating data entry and maintaining change records on-line, the change
management activity associated with metrics reporting can also be automated.
The issues that arise while writing a SCO are:
What is a discrete change?
Title:__________________________________________________________________
Category:__________ (0/1 error, 2 enhancement, 3 new feature, 4 other)
Initial Estimate Actual Rework Expended
Breakage: ____________ Analysis: _________ Test: __________
Rework: ____________ Implement: ________ Document: _____
Metrics
Analyst: ___________________________________________
Software Component: _________________________________
Resolution
Method: _____________ (inspection, analysis, demonstration, test)
Tester: __________________ Platforms: _____________ Date: _____________
Assessment
Name: ______________________________ Date: ____________
Project: ________________________________________________
Description
State: ___________ Release: _________ Priority: ___________
Acceptance: _________________________________ Date: ___________
Closure: ____________________________________ Date: ___________
Disposition
FIGURE 12-3. The primitive components of a software change order
Is it a change to a program unit or to a component, file, or a subsystem?

Is it a new feature, a defect resolution, or a performance enhancement?
In general, an SCO should be written against a single component so that it is easily
allocated to a single individual.
If resolution requires two people on two different teams, two discrete SCOs should be
filled up.
The basic fields of the SCO are title, description, metrics, resolution, assessment, and
disposition.
☺ Title.
􀂾 The title is suggested by the originator and is finalized upon acceptance by the
configuration control board – CCB.
􀂾 This field should include a reference to an external software problem report if
the change was initiated by an external person – such as a user.
☺ Description.
􀂾 The problem decomposition includes the name of the originator, date of
origination, CCB-assigned SCO identifier, and relevant version identifiers of
related support software.
􀂾 The textual problem description should provide as much detail as possible,
along with attached code excerpts, display snapshots, error messages, and any
other data that may help to isolate the problem or description the change needed.
☺ Metrics.
􀂾 The metrics collected for each SCO are important for planning, for scheduling
and for assessing quality improvement.
􀂾 Change categories are type 0 (critical bug), type 1 (bug), type 2 (enhancement),
type 3 (new feature), and type 4 (other).
􀂾 Upon acceptance of the SCO, initial estimates are made of the amount of
breakage and effort required to resolve the problem.
􀂾 The breakage item quantifies the volume of change, and the rework quantifies
the complexity of change.
􀂾 After resolution, the actual breakage is noted, and the actual rework effort is
further elaborated.
􀂾 The analysis item identifies the number of staff hours spent in understanding the
required change – re-creating, isolating, and debugging the problem if the
change is type 0 or 1; analysis and prototyping alternative solutions if it is type
2 or 3.
􀂾 The implement item identifies the staff hours necessary to design and implement
the resolution.
􀂾 The test item identifies the hours expended in testing the resolution.
􀂾 The document item identifies all effort expended in updating other artifacts such
as user manual or release description.
􀂾 Breakage quantifies the extent of change and can be defined in units SLOC,
function points, files, components, or classes.
􀂾 In the case of SLOC, a source file comparison program to quantify differences
may provide a simple estimate of the breakage.
☺ Resolution.
􀂾 This field includes the name of the person responsible for implementing the
change, the components changed, the actual metrics, and a description of the
change.
􀂾 The lowest level of component references should be kept at approximately the
level of allocation to an individual.
􀂾 A “component” allocated to a team is not a sufficiently detailed reference.
☺ Assessment.
􀂾 This field describes the assessment technique as inspection, analysis,
demonstration, or test.
􀂾 It should also reference all existing test cases and new test cases executed, and it
should identify all different test configurations, such as platforms, topologies,
and compilers.
☺ Disposition.
􀂾 The SCO is assigned one of the following states by the CCB:
􀂾 Proposed: written, pending CCB review
􀂾 Accepted: CCB-approved for resolution
􀂾 Rejected: closed, with rationale, such as not a problem, duplicate, obsolete
change, resolved by another SCO
􀂾 Archived: accepted but postponed until a later release
􀂾 In progress: assigned and actively being resolved by the development
organization
􀂾 In assessment: resolved by the development organization; being assessed
by a test organization
􀂾 Closed: completely resolved, with the concurrence of all CCB members
􀂾 A priority and release identifier can also be assigned by the CCB to guide the
prioritization and organization of concurrent development activities.
Configuration Baseline
A configuration baseline is a named collection of software components and supporting
documentation that is subject to change management and is upgraded, maintained, tested,
status-assessed, and obsolesced as a unit.
There are generally two classes of baselines: external product releases and internal testing
releases.
A configuration baseline is controlled formally as it is a packaged exchange between
groups.
For example, the development organization may release a configuration baseline to the
test organization.
A project may release a configuration baseline to the user for beta testing.
Generally, three levels of baseline releases are required for most systems: major, minor,
and interim.
Each level corresponds to a numbered identifier such as N.M.X, where N is the major
release number, M the minor release number, and X the interim release identifier.
A major release represents a new generation of the product or project.
A minor release represents the same basic product with enhanced features, performance,
or quality.
Major and minor releases are intended to be external product releases that are persistent
and supported for a period of time.
An interim release corresponds to a development configuration intended to be transient.
The shorted its life cycle, the better.
The figure on the following page shows examples of some release name histories for two
different situations:
Once software is placed in a controlled baseline, all changes are tracked.
A distinction must be made for the cause of a change.
Change categories are:
􀂾 Type 0:
Critical failures, which are defects that are nearly always fixed before nay external
release
These changes represent show-stoppers with an impact on the usability of the
software in its critical use cases.
􀂾 Type 1:
A bug or defect – with no impairment of the usefulness of the system or that can be
worked around.
These errors tend to correlate nuisances in critical use cases or to serious defects in
secondary use cases that have a low probability of occurrence.
􀂾 Type 2:
A change that is an enhancement rather than a response to a defect
Its purpose is to improve performance, testability, usability, or some aspect of
quality that represents good value engineering.
􀂾 Type 3:
A change that is necessitated by an update to the requirements
Such an update could be new features or capabilities that are outside the scope of the
current vision and business case.
􀂾 Type 4:
Changes not accommodated by the other categories
Examples: document only or a version upgrade to commercial components
The following table provides examples of these changes in the context of two different
project domains: a large-scale, reliable air traffic control system and a packaged software
development tool.
CHANGE
TYPE
AIR TRAFFIC CONTROL PROJECT
PACKAGED VISUAL MODELING TOOL
Type 0 Control deadlock and loss of flight data Loss of user data
Type 1 Display response time that exceeds the
requirement by 0.5 second
Browser expands but does not collapse
displayed entries
Type 2 Add internal message field for response
time instrumentation
Use of color to differentiate updates form
previous version of visual model
Type 3 Increase air traffic management
capacity from 1,200 to 2,400
simultaneous flights
Port to new platform such as Win-NT
Type 4 Upgrade from Oracle 7 to Oracle 8 to
improve query performance
Exception raised when interfacing to MS Excel
5.0 due to Windows resource management bug
TABLE 12-1. representative examples of changes at opposite ends of project spectrum
Typical project release sequence for a large-scale one-of-a-kind project
Prototype 0.1
Architecture 0.2
Architecture 0.3
0.3.1 0.3.2 1.0.1 2.0.1 2.0.2
Internal test release 1.0
Alpha test release 1.0
IOC: beta release 1.0
3.1.1 4.0.1
Beta release 3.1
Product release 3.1
Upgrade release 3.1
Typical project release sequence for a small commercial project
Prototype 0.1
Architecture 0.2
Architecture 0.3
3.1.1 3.1.2
Internal test release 1.0
Alpha test release 1.0
IOC: beta release 1.0
4.0.1 4.1.2
Beta release 3.1
Product release 4.0 Upgrade release 4.1
Upgrade release 4.2
FIGURE 12-4. Example release histories for a typical project and a typical product
Configuration Control Board [CCB]

A CCB is a team of people that functions as the decision authority on the content of
configuration baselines.
A CCB includes the software manager, software architecture manager, software
development manager, software assessment manager, and other stakeholders like
customer, software project manager, systems engineer, and user.
All these are integral to the maintenance of a controlled software delivery system.
CCBs take action through board meetings, on-line distribution, and concurrence.
The operational concept of an iterative development process must include comprehensive
and rigorous change management of the evolving software baselines.
The fundamental process for controlling the software development and maintenance
activities is described through the sequence of states traversed by an SCO.
The states an SCO transits are:
􀁿 [Proposed].
A proposed change is drafted and sent to the CCB.
It should include a technical description of the problem and an estimate of the
resolution effort.
􀁿 Accepted, archived, or rejected].
The CCB assign a unique identifier and accepts, archives, or rejects each proposed
change.
Acceptance includes the change for resolution in the next release;
Archiving accepts the change but postpones it for resolution in a future release; and
Rejection judges the change to be without merit, redundant with other proposed
changes, or out of scope.
The CCB verifies that all SCO fields are appropriate and accurate before accepting
the SCO, then assigns the SCO to a responsible person in the development
organization for resolution.
􀁿 [In progress].
The responsible person analyzes, implements, and tests a solution to satisfy the
SCO.
This task includes updating documentation, release notes, and SCO metrics actuals,
and submitting new SCOs, if necessary.
After getting a complete solution, the person completes the resolution section of the
SCO and submits it to the independent test team for assessment.
􀁿 [In assessment]
The independent test team assesses whether the SCO is completely resolved.
When the independent test team deems the change to be satisfactorily resolved, the
SCO is submitted to the CCB for final disposition and closure.
􀁿 [Closed].
When the development organization, independent test organization, and CCB
concur that the SCO is resolved, it is transitioned to a closed status.
12.2.3 INFRASTRUCTURES
From a process automation perspective, the organization’s infrastructure provides the
capital assets, including two key artifacts: a policy that captures the standards for project
software development processes, and an environment that captures an inventory of tools.
These tools are the building blocks from which project environments can be configured
efficiently and economically.
Organization Policy
The organization policy is packaged as a handbook defining the life cycle and the process
primitives – major milestones, intermediate artifacts, engineering repositories, metrics,
roles, and responsibilities.
The handbook provides a general framework for answering:

􀂾 What gets done? [activities and artifacts]
􀂾 When does it get done? [mapping to the life-cycle phases and milestones]
􀂾 Who does it? [team roles and responsibilities]
􀂾 How do we know that it is adequate? [checkpoints, metrics, and standards of
performance]
The need for balance is an important consideration in defining organizational policy.
Effective organizational policies have the following recurring themes:
􀀌 They are concise and avoid policy statements.
􀀌 They confine the policies to the real “shalls”, and then enforce them.
􀀌 They avoid using the word should in policy statements.
􀂾 a menu op options – shoulds – policies need a concise set of mandatory
standards – shalls.
􀀌 Waivers are the exception, not the rule.
􀀌 Appropriate policy is written at the appropriate level.
􀁀 There are many different organizational structures. Most software-intensive
companies have three distinct levels of organization, with a different policy focus
at each level:
􀂃 Highest organization level: standards that promise (1) strategic and long
term process improvements, (2) general technology insertion and
education, (3) comparability of project and business unit performance, (4)
mandatory quality control.
􀂃
Intermediate line-of-business level: standards that promote (1) tactical and
short0term process improvement, (2) domain-specific technology
insertion and training, (3) reuse of components, processes, training, tools,
and personnel experience, and (4) compliance with organizational
standards
􀂃 Lowest project level: standards that promote (1) efficiency in achieving
quality, schedule, and cost targets, (2) project-specific training, (3)
compliance with customer requirements, and (4) compliance with
organizational/business unit standards
􀁀 Standardization should focus on line-of-business units, not on the top-level
organization or the projects.
􀁀 Leverage from standardization is generally most effective at the business unit
level, where there is the most commonality and reuse across projects, processes,
and tools.
􀁀 Standardization of software development techniques and tools across lines of
business has proven to be difficult, because the process priorities, tools,
techniques, methods, and stakeholder cultures can be very different.
􀁀 Attempting to standardize across domains that have little commonality results in
either a highly diluted policy statement or a waiver process that is used too
frequently.
􀁀 Standardizing at too high a level is problematic; so is standardizing at too low a
level.
􀁀 If all project teams are left to their own devices, every project process and
environment will be locally optimized.
􀁀 Over time, the organization’s infrastructure for process improvement and growth
will erode.
The organization policy is the defining document for the organization’s software policies.
In any process assessment, this is the tangible artifact that says what to do.
From this document, reviewers should be able to question and review project and
personnel and determine whether the organization does what it says.
The following figure shows an outline for an organizational policy:

Organization Environment
The organization environment for automating the default process provides answers to
how things get done and the tools and techniques to automate the process.
􀂾 Components of an organization’s automation building blocks are:
􀂾 Standardized tool selections which promote common workflows and a higher ROI on
training
􀂾 Standard notations for artifacts, such as UML for design models, Ada 95 for
customdeveloped,
reliability-critical implementation artifacts
􀂾 Tool adjuncts such as existing artifact templates or customizations
􀂾 Activity templates – iteration planning, major milestone activities, configuration
control boards
􀂾 Other indirectly useful components of an organization’s infrastructure:
􀂾 A reference library of precedent experience for planning, assessing, and
improving process performance parameters [answers for: How well? How much?
Why?]
􀂾 Existing case studies, including objective benchmarks of performance for
successful project that followed the organizational process
􀂾 A library of project artifact examples like software development plants,
architecture descriptions, and status assessment histories
􀂾 Mock audits and compliance traceability for external process assessment
frameworks like Capability Maturity Model (CMM)
12.2.4 STAKEHOLDER ENVIRONMENTS
The transition to a modern iterative development process with supporting automation
should also include people in external organization that represent other stakeholders
participating in the development process.
They might include procurement agency contract monitors, end-user engineering support
personnel, third-party maintenance contractors, independent verification and validation
contractors, representatives of regulatory agencies, and others.
These stakeholder representatives also need access to development environment
resources so that they can contribute value to the overall effort.
Process-primitive definitions
A. Life-cycle phases (inception, elaboration, construction, transition)
B. Checkpoints (major milestones, minor milestones, status assessments)
C. Artifacts (requirements, design, implementation, deployment, management sets)
I
D. Roles and responsibilities (PRA, SEPA, SEEA, project teams)
Organizational software policies
A. Work breakdown structure
B. Software development plan
C. Baseline change management
D. Software metrics
E. Development environment
F. Evaluation criteria and acceptance criteria
G. Risk management
II
H. Testing and assessment
III Waiver policy
Appendixes
A. Current process assessment
IV
B. Software process improvement plan
FIGURE 12-5. Organization policy outline
An on-line environment accessible by the external stakeholders allows them to participate

in the process as follows:
♥ Accept and use executable increments for hands-on evaluation
♥ Use the same on-line tools, data, and reports that the software development
organization uses to manage and monitor the project
♥ Avoid excessive travel, paper interchange delays, format translations, paper
and shipping costs, and other overhead costs
The following illustrates the new opportunities for value-added activities by external
stakeholders in large contractual efforts:
There are several important reasons for extending development environment resources
into stakeholder domains. They are:
􀁿 Technical artifacts are not just paper.
Electronic artifacts in rigorous notations such as visual models and source code are
viewed more efficiently by using tools with browsers.
􀁿 Independent assessments of the evolving artifacts are encouraged by electronic
read-only access to on-line data such as configuration baseline libraries and the
change management database.
Ma
nagement
Ma
nagement
Artifact Releases Artifact Baselines
Tool Subset
Stakeholder Activities
􀁀 Configuration control board
participation
􀁀 Test scenario development
􀁀 Risk management analysis
􀁀 Metrics trend analysis
􀁀 Artifact reviews, analyses,
audits
􀁀 Independent alpha and beta
testing
Workflow automation, metrics automation
Change management, document automation
Requirements management
Visual modeling
Editor-compiler-debugger
Test automation, defect tracking
Defect tracking
Environment Tools and Process
Automation
Electronic
Exchange
FIGURE 12-6.
Extending
environments
into
stakeholder
domains
Reviews and inspections, breakage/rework assessments, metrics analyses, and beta

testing can be performed independent of the development team.
􀁿 Paper documents also should be delivered electronically to reduce production costs
and turnaround time.
Continuous and expedient feedback is more efficient, tangible, and useful when the
environment resources are electronically accessible by stakeholders.
For such a shared environment to be possible, the development teams should create an
open environment and provide adequate resources to accommodate customer access.
From the stakeholders’ side, they should avoid abusing the access and interrupting
development work.
They should participate by adding value.
Internet and intranet technology are making paperless environments economical.
1. Explain the mapping between process workflows and the software development
tools, using a neat diagram. (Page 168-172, Fig. 12-1/P 169)
2. The project environment artifacts evolve through three discrete states – the
prototyping environment, the development environment, and the maintenance
environment. Explain the four important environment disciplines for the above
evolution. (Page 172-185)
3. Explain how round-trip engineering is a key requirement for environments that
support iterative development. (Page 173-174)
4. Explain about software change orders (SCOs). (Page 175-178, Fig. 12-3/P176)
5. a) Explain, using an example, how release histories are captured in configuration
baselines. (Page 178-179, Fig. 12-4/P 179)
b) Explain the SCO transitioning process including the role of the configuration
control board (CCB). (P 179-181)
6. Explain the role of infrastructure in process automation. (Page 181-184)
7. Explain the effects of and reasons for extending developer environment resources
into stakeholder domains. (Page 184-185, Fig. 12-6/P 185)
CHAPTER-13 PROJECT CONTROL AND PROCESS INSTRUMENTATION
The central management issues of complex software to be tackled by a modern software

development process are:
1. Getting the design right by focusing on the architecture first
2. Managing risk through iterative development
3. Reducing the complexity with component-based techniques
4. Making software progress and quality tangible through instrumented change
management
5. Automating the overhead and bookkeeping activities through the use of round-trip
engineering and integrated environments
The topic for this chapter is the fourth issue, above.
It is inherently difficult to manage what cannot be measured objectively.
The conventional software process, where the intermediate product were paper
documents, the objective measurement became a major problem.
Software metrics instrument the activities and products of the software development/
integration process.
Software processes with manual procedures and human-intensive activities cant achieve
much success.
In a modern development process, the most important software metrics are simple,
objective measures of how various perspectives of the product and project are changing.
The quality of software products and the progress made toward project goals must be
measurable throughout the software development cycle.
The goals of software metrics are to provide the development team with the following:
􀂾 An accurate assessment of progress to date
􀂾 Insight into the quality of the evolving software product
􀂾 A basis for estimating the cost and schedule for completing the product with
increasing accuracy over time
13.1 THE SEVEN CORE METRICS
Of the many different metrics applicable in managing a modern process, there are seven
core metrics to be used on all software projects.
Three are MANAGEMENT INDICATORS:
􀁀 Work and progress – work performed over time
􀁀 Budgeted cost and expenditures – cost incurred over time
􀁀 Staffing and team dynamics – changes in personnel over time
Four are QUALITY INDICATORS:
♥ Change traffic and stability – change traffic over time
♥ Breakage and modularity – average breakage per change over time
♥ Rework and adaptability – average rework per change over time
♥ Mean time between failures (MTBF) and maturity – defect rate over time
The following table describes the seven core software metrics:
TABLE 13-1. Overview of the seven core metrics
METRIC PURPOSE PERSPECTIVES
Work and progress Iteration planning, plan vs.
actuals, management indicator
SLOC, function points, object
points, scenarios, test cases,
SCOs
Budgeted cost and expenditures Financial insight, plan vs.
actuals, management indicator
Cost per month, full-time staff
per month, percentage of
budget expended
TABLE 13-1. Overview of the seven core metrics (Continued)

METRIC PURPOSE PERSPECTIVES
Staffing and team dynamics Resource plan vs. actuals,
hiring rate, attrition rate
People per month added,
people per month leaving
Change traffic and stability Iteration planning,
management indicator of
schedule convergence
SCOs opened vs. SCOs closed,
by type (0/1/2/3/4), by release/
component/subsystem
Breakage and modularity Convergence, software scrap,
quality indicator
Reworked SLOC per change,
by type (0/1/2/3/4), by release/
component/subsystem
Rework and adaptability Convergence, software rework,
quality indicator
Average hours per change, by
type (0/1/2/3/4), by release/
component/subsystem
MTBF and maturity Test coverage/adequacy,
robustness for use, quality
indicator
Failure counts, test hours until
failure, by release/component/
subsystem
Each metric has two dimensions:
① a static value used as an objective, and
② the dynamic trend used to manage the achievement of the objective.
Metrics values provide one dimension of insight; metrics trends provide a perspective for
managing the process.
Metrics trends with respect to time provide insight into how the process and the product
are evolving.
Iterative development is about managing change, and measuring change is the most
important aspect of the metrics program.
The fundamental goal of management is: predictable cost and schedule performance for a
given level of quality.
Till this goal is achieved, absolute values of productivity and quality improvement will be
secondary issues.
The seven core metrics can be used in different ways to help manage projects and
organizations:
In an iterative development project or an organization structured around software line-
ofbusiness,
the historical values of previous iterations and projects provide precedent data
for planning subsequent iterations and projects.
Thereby, a project or organization can improve its ability to predict the cost, schedule, or
quality performance of future activities.
The attributes of the seven core metrics include:
􀂾 They are simple, objective, easy to collect, easy to interpret, and hard to misinterpret.
􀂾 Collection can be automated and non-intrusive
􀂾 They provide for consistent assessments throughout the life cycle and are derived
from the evolving product baselines than from a subjective assessment
􀂾 They are useful to both management and engineering personnel for communicating
progress and quality in a consistent format
􀂾 Their fidelity improves across the life cycle.
Metrics applied to the engineering stage will less accurate than those applied to the
production stage.
So, the prescribed metrics are tailored to the production stage, when the cost risk is
high and management value is leveraged.
Metrics activity during the engineering stage is geared toward establishing initial
baselines and expectations in the production stage plan.
13.2 MANAGEMENT INDICATORS

There are three fundamental sets of management metrics: technical progress, financial
status, and staffing progress.
Examination of these perspectives helps in assessing whether a project is on budget and
on schedule. Resource expenditures are known in terms of costs and schedule.
The problem is in assessing the technical progress made.
Conventional projects, with their intermediate products in paper documents, relied on
subjective assessment of technical progress or measured the number of documents
completed.
Though these documents reflected progress in expending energy, they were not indicative
of useful work being accomplished.
The management indicators include standard financial status based on an earned value
system, objective technical progress metrics tailored to the primary measurement criteria
for each major team of the organization, and staffing metrics that provide insight into
team dynamics.
13.2.1 WORK AND PROGRESS
The various activities of an iterative development project can be measured by defining a
planned estimate of the work in an objective measure, then tracking progress – work
completed over time – against that plan.
Each major organizational team must have at least one primary progress perspective.
Measurements are made against such a perspective.
For the standard teams the default perspectives of this metric are:
􀁀 Software architecture team: use cases demonstrated
􀁀 Software development team: SLOC under baseline change management, SCOs closed
􀁀 Software assessment team: SCOs opened, test hours executed, evaluation criteria met
􀁀 Software management team: milestones completed
13.2.2 BUDGET COST AND EXPENDITURES
Measuring cost expenditures over the life cycle is necessary to maintain management
control.
Using the metrics [for work and progress] judiciously, a more objective assessment of
technical progress can be performed to compare with cost expenditures.
In an iterative development process it is important to
􀀌 plan the near-term (time <= 6 months) in detail, and
􀀌 leave the far-term activities as rough estimates
􀀌 to be refined as the current iteration comes to an end and
planning for the next iteration becomes crucial.
100%
Work
Project Schedule
Release 1
􀁓
Release 2
􀁓
Release 3
􀁓
􀁓
FIGURE 13-1. Expected progress for a project with three major releases
Tracking financial progress takes on an organization-specific format.

One common approach to financial performance measurement is use of an earned value
system.
This provides highly detailed cost and schedule insight.
Its major weakness for software project, {in the engineering stage,} is the inability to
assess the technical progress as [% of completion] objectively and accurately.
Earned value systems are effective for the production stage, where there is high-fidelity
tracking of actuals vs. plans and predictable results.
The other core metrics provide a framework for detailed and realistic quantifiable backup
data to plan and track against, especially in the production stage of a software project,
when the cost and schedule expenditures are highest.
The basis parameters of an earned value system, for a modern software process,
measured in units of currency, are:
♥ Expenditure plan:
􀂾 The planned spending profile for a project over its planned schedule
􀂾 For labor-intensive projects like software, this tracks the staffing profile.
♥ Actual progress:
􀂾 The technical accomplishment relative to the planned progress underlying the
spending profile.
􀂾 In a healthy project, the actual progress tracks planned progress closely.
♥ Actual cost:
􀂾 The actual spending profile over the project’s schedule.
􀂾 In a healthy project, the actual progress tracks planned progress closely.
♥ Earned value:
􀂾 The value that represents the planned cost of the actual progress.
♥ Cost variance:
􀂾 The difference between the actual cost and the earned value.
􀂾 Positive values imply over-budget situations, negative ones mean under-budget
situations.
♥ Schedule variance:
􀂾 The difference between the planned cost and the earned value.
􀂾 Positive values imply behind-schedule situations, and negative values correspond
to ahead-of schedule situations.
The following figure provides a graphical perspective of theses parameters along with a
simple example of a project situation:
100%-
Progress
Schedule variance (currently 10% behind)
Cost variance (currently 10% under)
Current time
Planned progress
Actual progress (currently 35%)
(currently 25%)
Actual cost
Expenditures
(currently 25%)
Time
FIGURE 13-2. The basic parameters of an earned value system
The main purpose of the other core metrics is to provide management and engineering
teams with a more objective approach for assessing actual progress with more accuracy.
For software projects the culture of the team, the experience of the team, and the style of
the development [the process, its rigor, and its maturity] should drive the criteria used to
assess the progress objectively.
13.2.3 STAFFING AND TEAM DYNAMICS
An iterative development project should start with a small team until the risks in the
requirements and architecture are resolved.
Staffing can vary based on the overlap of iterations and other project-specific
circumstances.
For discrete, one-of-a-kind development efforts – such as building a corporate
information system – the staffing profile in the following figure is typical:
In such development projects, the maintenance team is expectably smaller than the
development team.
For a commercial product development, the sizes of the maintenance and development
teams may be the same.
In case of long-lived, continuously improved products, maintenance is a continuous
construction of new and better releases.
Tracking actual vs. planned staffing is a necessary and well-understood management
metric.
Another important management indicator of changes in project momentum is: the
relationship between attrition and additions.
Low attrition of good people is a sign of success.
Engineers are highly motivated by making progress in getting something to work; this is
the recurring theme underlying an efficient iterative development process.
If this motivation is not there, good engineers will migrate elsewhere.
An increase in unplanned attrition is a sure sign of trouble.
The causes of such attrition can vary, but they are usually personnel dissatisfaction with
management methods, lack of teamwork, or probability of failure in meeting the planned
objectives.
Inception
Elaboration
Construction
Transition
Effort: 5%
Schedule:
10%
Effort: 20%
Schedule:30%
Effort: 65%
Schedule: 50%
Effort:10%
Schedule:
10%
Staffing
Project Schedule
FIGURE 13-4. Typical staffing profile
13.3 QUALITY INDICATORS

the four quality indicators – change traffic and stability, breakage and modularity, rework
and adaptability, and MTBF and maturity – are based on the measurement of software
change across evolving baselines of engineering data like design models and source code.
13.3.1 CHANGE TRAFFIC AND STABILITY
Overall change traffic is an indicator of progress and quality.
Change traffic is defined as the number of software change orders opened and closed
over the life-cycle. .
The change traffic metric can be collected by change type, by release, across all releases,
by team, by components, by subsystem, and so forth.
Coupled with the work and progress metrics, it provides insight into the stability of the
software and its convergence toward stability – or divergence and instability.
Stability is defined as the relationship between opened versus closed SCOs.
The change traffic relative to the release schedule provides insight into schedule
predictability – the primary value of this metric and an indicator of the performance of
the process. The other three quality metrics focus more on the quality of the product.
13.3.2 BREAKAGE AND MODULARITY
Breakage is defined as the average extent of change, which is the amount of software
baseline that needs rework. .
The rework is in terms of SLOC, function points, components, subsystems, files, etc.
Modularity is the average breakage trend over time. .
For a healthy project, the trend expectation is decreasing or stable, as in figure 13-6.
Project Schedule
Closed
Open
Released baseline
Change Traffic
Implementation
Changes
Design
Changes
Released baselines
Breakage
Project Schedule
FIGURE 13-5. Stability expectation over a healthy project’s life cycle
FIGURE 13-6. Modularity expectation over a healthy project’s life cycle
The indicator provides insight into the benign or malignant character of software change.
In a mature iterative process, earlier changes are expected to result in more scrap than
later changes.
Breakage trends that increase with time indicate that product maintainability is suspect.
13.3.3 BREAKAGE AND MODULARITY
Rework is defined as the average cost of change, which is the effort to analyze, resolve,
and retest all changes to software baselines. .
Adaptability is defined as the rework trend over time. ..
For a healthy project, the trend expectation is decreasing or stable, same as in figure 13-6,
with the y-axis representing rework.
Not all changes are created equal.
Some changes can be made in a staff-hour, while others take staff-weeks.
This metric provides insight into rework measurement.
In a mature iterative process, earlier changes – architectural changes that affect multiple
components and people – require more rework than later changes – implementation
changes that are confined to a single person or component.
Rework trends that are increasing with time clearly indicate that product maintainability
is suspect.
13.3.4 MTBF AND MATURITY
MTBF is defined is the average usage time between software failures. . .
MTBF is computed by dividing the test hours by the number of type 0 and type 1 SCOs.
Maturity is defined as the MTBF trend over time. ..
Effective test infrastructure must be established for early insight into maturity.
For monolithic software the conventional software approaches focused on every line of
code, every branch, and so forth for complete test coverage.
In the distributed and componentized software systems, complete test coverage is
achievable only for discrete components.
Systems of components are more efficiently tested by using statistical techniques.
So, the maturity metrics measure statistics over usage time rather than product coverage.
Released baselines
MTBF
Project Schedule
FIGURE 13-8. Maturity expectation over a healthy project’s life cycle
Software errors are categorized into two types: ⑴deterministic and ⑵nondeterministic.
Physicists categorized them as ⑴Bohr-bugs and ⑵Heisen-bugs respectively.
⑴ Bohr-bugs are a class of errors that always result when the software is stimulated in a
certain way.
These errors are caused by coding errors, and changes are isolated to single
components.
Conventional software executing a single program on a single processor typically
contained only Bohr-bugs.
⑵ Heisen-bugs are software faults that are coincidental with a certain probabilistic
occurrence of a given situation.
These errors are caused by design errors, and are not repeatable even when the
software is stimulated in the same apparent way.
To provide test coverage and resolve the statistically significant Heisen-bugs,
extensive statistical testing under realistic and randomized usage scenarios is
necessary.
Modern, distributed systems with many interoperating components executing across a
network of processors are vulnerable to Heisen-bugs.
Establishing an initial test infrastructure that allows execution of randomized usage
scenarios early in the life cycle and continuously evolves the breadth and depth of usage
scenarios to optimize coverage across the reliability-critical components is the way to
mature a software product.
The established baselines should be continuously subjected to test scenarios.
From this base of testing, reliability metrics can be extracted.
Maximizing test time increases meaningful insight into product maturity.
This testing approach provides a powerful mechanism for encouraging automation in the
test activities early in the life cycle.
This helps in monitoring performance improvements and measuring realiability.
13.4 LIFE-CYCLE EXPECTATIONS
There is no mathematical or formal derivation for using the seven core metrics.
The reasons for selecting the seven core metrics are:
􀁀 The quality indicators are derived form the evolving product than from the artifacts.
􀁀 They provide insight into the waste generated by the process.
Scrap and rework metrics are a standard measurement perspective for manufacturing
processes.
􀁀 They recognize the inherently dynamic nature of an iterative process.
They explicitly concentrate on the trends or changes with respect to time than
focusing on value.
􀁀 The combination of insight from the current value and the current trend provides
tangible indicators for management action.
The actual values of these metrics vary across projects, organizations, and domains.
The relative trends should follow the following general pattern:
TABLE 13-3. The default pattern of life-cycle metrics evolution

METRIC INCEPTION ELABORATION CONSTRUCTION TRANSITION
Progress
Architecture
Applications
5%
30%
<5%
25%
90%
20%
90%
100%
85%
100%
100%
100%
Expenditures
Effort
Schedule
Low
5%
10%
Moderate
25%
40%
High
90%
90%
High
100%
100%
Staffing Small team Ramp up Steady Varying
Stability
Architecture
Applications
Volatile
Volatile
Volatile
Moderate
Moderate
Volatile
Moderate
Stable
Moderate
Stable
Stable
Stable
Modularity
Architecture
Applications
50% - 100%
>50%
>80%
25% - 50%
> 50%
> 80%
<25%
<15%
<25%
5% - 10%
<5%
<10%
Adaptability
Architecture
Applications
Varying
Varying
Varying
Varying
Moderate
Varying
Benign
Benign
Moderate
Benign
Benign
Benign
Maturity
Architecture
Applications
Prototype
Prototype
Prototype
Fragile
Usable
Fragile
Usable
Robust
Usable
Robust
Robust
Robust
A mature development organization should describe metrics targets that are more definite
and precise for its line of business and specific processes.
13.5 PRAGMATIC SOFTWARE METRICS
Measuring help the decision makers ask the right questions, understand the context, and
make objective decisions.
Because of the dynamic nature of software projects, these must always be available,
tailor-able to different subsets of the evolving product – release, version, component,
class, and maintained so that trends can be assessed with reference to time.
This can be achieved when the metrics are maintained on-line as an automated byproduct.
The basic characteristics of a good metric are:
1. It is considered meaningful by the customer, manager, and performer.
A metric will be used only when a stakeholder sees at as meaningful.
Customers accept metrics that are demonstrated to be meaningful for the
developer.
2. It demonstrates quantifiable correlation between process perturbations and
business performance.
The real organizational goals and objectives are financial: cost reduction, revenue
increase, and margin increase.
3. It is objective and unambiguously defined.
Objectivity should translate into numeric representation – numbers, percentages,
ratios, opposed to textual representation – excellent, good, etc.
Ambiguity is minimized with well-understood units of measurement like staffmonth,
SLOC, change, function point, class, scenario, requirement, etc.
4. It displays trends.
It is a very important perspective to understand the change in the value of a metric
with respect to time, subsequent projects, subsequent releases, and so forth.
A metric rarely drives the appropriate action directly.
A metric presents a perspective.
The decision maker has to interpret the metric and decide the action.
5. It is a natural by-product of the process.

The metric doesn’t introduce new artifacts or overhead activities.
It is derived directly from the engineering and management workflows.
6. It is supported by automation.
Metrics are successful when collected and reported by automated tools as the
tools require rigorous definitions of the data they process.
Metrics display effects of problems; the causes require synthesis of multiple perspectives
and reasoning.
For example, reasoning is required to interpret the following situations correctly:
A low number of change requests to software baseline may mean:
The software is mature and error-free, or
The test team needs to be more active.
A software change order kept open for along time may mean:
The problem was simple to diagnose and the solution required substantial rework,
or
The diagnosis is a time-consuming affair and the solution requires a simple
change to a single line of code.
A large increase in personnel in a given month may cause:
Progress to increase proportionately, if they are trained and productive, or
Progress to decelerate, if the new recruits are untrained.
13.6 METRICS AUTOMATION
There are a number of opportunities to automate the project control activities:
For managing against a plan – a software project control panel (SPCP) to maintain an
online
version of the status of evolving artifacts provides a key advantage.
This concept was recommended by the Airlie Software Council, using the
metaphor of a project “dashboard”.
The idea is to provide a display panel that integrates data from multiple sources to
show the current status of some aspect of the project.
For example: the software manager can see a display with overall project values, a
test manager can see a display focused on metrics specific to a beta release, and
development managers can see the data concerning the subsystems and
components they are responsible for.
The panel can support standard features like warning lights, thresholds, variable
scales, digital formats, and analog formats to present an overview of the current
situation.
It can also provide extensive capability for detailed situation analysis.
This automation can improve management insight into progress and quality trends
and improve the acceptance of metrics by the engineering team.
To implement a complete SPCP, it is necessary to define and develop the following:
Metrics primitives: indicators, trends, comparisons, and progressions.
A graphical user interface: GUI support for a project manager role, and flexibility
to support other roles
Metrics collection agents: data extraction from the environment tools that
maintain the engineering notations for the artifact sets.
Metrics data management server: data management support for populating the
metrics displays of the GUI and storing the data extracted by the agents
Metrics definitions: actual metrics presentations for requirements progress –
extracted from requirements set artifacts, design progress – extracted from design
set artifacts, implementation progress – extracted from implementation set
artifacts, assessment progress – extracted from deployment set artifacts, and other
progress dimensions – extracted from manual sources, financial management
systems, management artifacts, etc.
Actors: the monitor and the administrator
Specific monitors – called roles – include project managers, software development team
leads, software architects, and customers.
For every role, there is a specific panel configuration and scope of data presented.
Each role performs the same general use cases, with a different focus.
Monitor: defines panel layouts from existing mechanisms, graphical objects, and
linkages to project data; queries data to be displayed at different levels of
abstraction.
Administrator: installs the system; defines new mechanisms, graphical objects,
and linkages; handles achieving functions, defines composition and
decomposition structures for displaying multiple levels of abstraction
The whole display is called a panel.
Within a panel are graphical objects, which are types of
layouts – such as dials and bar charts – for information.
Each graphical object displays a metric.
A panel contains a number of graphical objects
positioned in a particular geometric layout.
A metric shown in a graphical object is labeled with the metric type, the summary
level, and the instance name – such as lines of code, subsystem, server1.
Metrics can be displayed in two modes: value, referring to a point in
time, or graphs, referring to multiple and consecutive points in time.
Only some of the display types are applicable to graph metrics.
Metrics can be displayed with or without control values.
A control value is an existing expectation – absolute or relative –
used for comparison with a dynamically changing metric.
For example, a plan for a given progress metric is a
control value for comparing the actuals of that metric.
Thresholds are another example of control values.
Crossing a threshold may result in a state change
that needs to be obvious to a user.
Control values can be shown in the same graphical object as
the corresponding metric, for visual comparison by the user.
Indicators may display data in formats that are binary – such as black and white,
tertiary – such as red, yellow, and green, digital – integer or float, or some enumerated
data type – a sequence of discrete values like sun …. sat, ready-aim-fire, jan … dec.
Indicators also provide a mechanism to be used to summarize a
condition or circumstance associated with another metric, or
relationships between metrics and their associated control values.
A trend graph presents values over time and permits upper and lower thresholds to be
defined.
Crossing a threshold could be linked to an associated indicator to depict a noticeable state
change from green to red or vice versa.
Trends support user-selected time increments – such as day, week, month, quarter, year.
A comparison graph presents multiple values together, over time.
Convergence or divergence among values may be linked to an indicator.
A progression graph presents percent complete, where elements of progress are shown as
transitions between states and an earned value is associated with each state.
Trends, comparisons, and progressions are illustrated in the following figure:
Comparison:
Comparison of N values with
the same units over time.
Example: open action items
vs. closed action items
Metric Value 1
Metric Value 2
Metric Value
Time
Expected Value
Actual Value
100%-
% Complete
Time
Progress: Plan vs. actuals over time
Actual Value
Upper Threshold
Lower Threshold
Trend: Comparison of a value over
time against known thresholds.
Example: design model change traffic
Metric Value
Time
FIGURE 13-9(a) Examples of the fundamental metrics
FIGURE 13-9(b) Examples of the fundamental metrics
FIGURE 13-9(c) Examples of the fundamental metrics
With the help of user-defined, linear structure metric information can be summarized.
For example, lines of code can be summarized by unit, subsystem, and project.
The project is the top-level qualifier for all data of the top-level context set.
Summary structures can be defined for lower levels, and display levels can be selected
based on previously defined structures, and drilled down to lower levels.
The following figure illustrates a simple example of an SPCP for a project.
In this example, the project manager role has defined a top-level display with four
graphical objects.
1. Project activity status.
The graphical object in the upper left provides an overview of the status of the
top-level WBS elements.
The seven elements are coded red, yellow, and green to reflect current earned
value status.
Green would represent ahead of plan, yellow for within 10% of plan, and red
identifies elements with a greater than 10% cost or schedule variance.
This graphical object provides several examples of indicators: tertiary colors, the
actual percentage, and the current first derivative – up arrow means getting better,
down arrow means getting worse.
2. Technical artifact status.
The graphical object in the upper right provides an overview of the status of the
evolving technical artifacts.
The Req light displays an assessment of the current state of the use case models
and requirements specifications.
The Des light displays about the design models, the Imp light for the source code
baseline, and the Dep light for the test program.
3. Milestone progress.
The graphical object in the lower left provides a progress assessment of the
achievement of milestones against plan and provides indicators of the current
values.
4. Action item progress.
The graphical object in the lower right provides a different perspective of
progress, showing the current number of open and closed issues.
Top-Level WBS Activities
Management - 4% ↓
Environment + 1%↑
Requirements + 6%↑
Design - 5% ↓
Implementation -25%↓
Assessment - 2% ↑
Deployment - 2% ↑
Technical Artifacts
Actuals (32)
Plan (27)
Milestone Progress Action Item Progress
Open (12)
Closed
Req Des Imp Dep
FIGURE 13-10. Example SPCP display for a top-level project situation
The above example of a progress metric implementation is trivial.

The format and content of a project panel are configurable to the software project
manager’s preference for tracking metrics of top-level interest.
An SPCP should support tailoring and provide the capability to drill down into the details
for any given metric.
The following top-level use case corresponds to a monitor interacting with the control
panel. It describes the basic operational concept for an SPCP.
♥ Start the SPCP.
The SPCP starts and shows the most current information saved on the last use of the
SPCP.
♥ Select a panel preference.
The user selects default panel preferences from a list of predefined preferences.
The SPCP displays the selected preferences.
♥ Select a value or graph metric.
The user selects whether the trend is to be shown as a given point in time or in a
graph.
The default for values is the most recent measurement available and that of trends is
monthly.
♥ Select to superimpose controls.
The user can request for the control values for a pointed metric and point in time to be
displayed.
In the case of trends, the controls are shown superimposed with the metric.
♥ Drill down to trend.
The user points to a graphical object displaying a point in time and drills down to
view the values for the metric.
♥ Drill down to point in time.
The user points to a graphical object displaying a trend and drills down to view the
values for that metric.
♥ Drill down to lower levels of information.
The user points to an object displaying a point in time and drills down to view the
next level of information.
♥ Drill down to lower level of indicators.
The user points to an object displaying an indicator and drills down to view the
breakdown of the next level of indicators.
The SPCP is an example of metrics automation approach that collects, organizes, and
reports values and trends extracted directly from the evolving engineering artifacts.
Metrics automated by the environment only will be acceptable to software engineers.
1. Describe the seven core metrics for project control and process instrumentation.
2. Describe the four quality indicators.
3. Discuss the reasons behind the choice of the seven core metrics.
4. List out the basic characteristics of a good metric.
5. Describe the “dash board” method of metrics automation.
6. List out the contents of a top-level use case of the basic operational concept for an
SPCP.
CHAPTER-14 TAILORING THE PROCESS
It is necessary to tailor the software management efforts to the specific needs of the
project at
hand.
The software management process uses different processes for a commercial software
tool
developer compared to that of a software integrator of automating the security system for
a
nuclear plant.
A mature process and effective software management approaches offer greater value to
the largescale
software integrator than for a small-scale tool developer.
All the same, the ROI realized by better software management approaches is worthwhile
for any
software organization.
14.1 PROCESS DISCRIMINANTS
In tailoring the management process to a specific domain or project, there are two
dimensions of
discriminating factors:
􀂾 technical complexity, and
􀂾 management complexity.
The following figure illustrates these two dimensions of process variability and shows an
example project application:
The formality of reviews, the quality control of artifacts, the priorities of concerns, and
other
process instantiation parameters are governed by the point a project occupies in these two
dimensions.
The priorities along the two dimensions are summarized in the figure on the following
page.
A process framework is not a project-specific process implementation with a well-
defined recipe
for success.
Judgment must be injected, and the methods, techniques, culture, formality, and
organization
must be tailored to the specific domain to achieve a process implementation to succeed.
There are six process parameters that cause major differences among project processes:
These are critical dimensions that a software project manger must consider when tailoring
a
process framework to create a practical process implementation.
Higher Technical Complexity
􀁀 Embedded, real-time, distributed, fault-tolerant
􀁀 High-performance, portable
􀁀 Unprecedented, architecture re-engineering
Lower Technical Complexity
􀁀 Straightforward automation, single threaded
􀁀 Interactive performance, single platform
􀁀 Many precedent systems, application re-engineering
Lower
Management
Complexity
􀂾 Smaller scale
􀂾 Informal
􀂾 Few stakeholders
􀂾 “Products”
Higher
Management
Complexity
􀂾 Larger scale
􀂾 Contractual
􀂾 Many stakeholders
􀂾 “Projects”
Embedded
automotive
application
Commercial
compiler
Telecom
switch
DOD
weapon
system
Air
traffic
control
system
Business
spreadsheet
Small
Business
simulation
Enterprise
application
e.g. order
entry
system
Large-scale
simulation
Enterprise
information
system DOD MIS
Average software
project
5 to 10 people
10 to 12 months
3 to 5 external interfaces
Some unknown risks
FIGURE 14-1. The two primary dimensions of process variability
14.1.1 SCALE
The single most important factor in tailoring a software process framework is the total
scale of
the application.
There are many ways to measure scale:
􀁿 Number of SLOC,
􀁿 Number of function points,
􀁿 Number of use cases, and
􀁿 Number of dollars
From a process tailoring perspective, the primary measure of scale is the size of the team.
As the headcount increases, the importance of consistent interpersonal communications
becomes
paramount.
Generally, five people are an optimal size for an engineering team. Most people can
manage four
to seven things at a time.
There are fundamentally different management approaches to manage a team of 1
(trivial), a
team of 5 (small), a team of 25 (moderate), a team of 125 (large), a team of 625 (huge),
and so
on.
As the team size grows, a new level of personnel management is introduced at a factor of
5.
This model can be used to describe some of the difference among project of different
sizes.
Trivial-sized projects require almost no management overhead – planning,
communication,
coordination, progress assessment, review, administration.
There is no need to document the intermediate artifacts.
Higher Technical Complexity
Lower Technical Complexity
Lower
Management
Complexity
Higher
Management
Complexity
FIGURE 14-2. Priorities for tailoring the process framework
􀀌 Less emphasis on risk management
􀀌 Less process formality
􀀌 More emphasis on individual skills
􀀌 Longer production and transition
phases
􀀌 More emphasis on risk management
􀀌 More process formality
􀀌 More emphasis on teamwork
􀀌 Longer inception and elaboration
phases
􀀌 More domain experience required
􀀌 Longer inception and elaboration
phases
􀀌 More iterations for risk management
􀀌 Less-predictable costs and schedules
􀀌 More emphasis on existing assets
􀀌 Shorter inception and elaboration
phases
􀀌 Fewer iterations
􀀌 More-predictable costs and schedules
Workflow is single-threaded.
Performance is highly dependent on personnel skills.
Small projects – 5 people – require very little management overhead, but team leadership
toward
a common objective is crucial.
There is some need to communicate the intermediate artifacts among team members.
Project milestones are easily planned, informally conducted, and easily changed.
There is a small number of individual workflows.
Performance depends primarily on personnel skills.
Process maturity is relatively unimportant.
Individual tools can have a considerable impact on performance.
Moderate-sized projects – 25 people – require moderate management overhead, including
a
dedicated software project manger to synchronize team workflows and balance resources.
Overhead workflows across all team leads are necessary for review, coordination, and
assessment.
There is a definite need to communicate the intermediate artifacts among teams.
Project milestones are formally planned and conducted, and the impacts of changes are
benign.
There is a small number of concurrent team workflows, each with multiple individual
workflows.
Performance is highly dependent on the skills of key personnel – the team leads.
Process maturity is valuable.
An environment can have a considerable impact on performance, but success can be
achieved
with certain key tools in place.
Large projects – 125 people – require substantial management overhead, including a
dedicated
software project manager and several subproject managers to synchronize project-level
and
subproject-level workflows and to balance resources.
There is significant expenditure in overhead workflows across all team leads for
dissemination,
review, coordination, and assessment.
Intermediate artifacts are explicitly emphasized to communicate engineering results
across many
diverse teams.
Project milestones are formally planned and conducted, and changes to milestone plans
are
expensive.
Large numbers of concurrent team workflows are necessary, each with multiple
individual
workflows.
Performance is highly dependent on the skills of key personnel – subproject managers
and team
leads.
Project performance is dependent on average people, for two reasons:
1. There are numerous mundane tasks in any large project, especially in the overhead
workflows.
2. The probability of recruiting, maintaining, and retaining a large number of exceptional
people is small.
Process maturity is necessary, particularly the planning and control aspects of managing
project
commitments, progress, and stakeholder expectations.
An integrated environment is required to manage change, automate artifact production,
and
maintain consistency among the evolving artifacts.
Huge projects – 625 people – require substantial management overhead, including
multiple
software project managers and many subproject managers to synchronize project-level
and
subproject-level workflows and balance resources.
There is significant expenditure in overhead workflows across all team leads for
disseminating,
review, coordination, and assessment.
Intermediate artifacts are explicitly emphasized to communicate engineering results
across many
diverse teams.
Project milestones are very formally planned and conducted, and changes to milestone
plans
cause malignant re-planning.
There are very large numbers of concurrent team workflows, each with multiple
individual
workflows.
Performance is highly dependent on the skills of key personnel – subproject managers
and team
leads.
Project performance is dependent on average people.

Software process maturity and domain experience are mandatory to avoid risk and ensure
synchronization of expectations of all the numerous stakeholders.
A mature, highly integrated, common environment across the development teams is
necessary to
manage change, automate artifact production, maintain consistency among the evolving
artifacts,
and improve the return on investment of common processes, common tools, common
notations,
and common metrics.
The following table summarizes some key differences in the process primitives for small
and
large (team-sized) projects:
TABLE 14-1. Process discriminators that result from differences in project size
PROCESS
PRIMITIVE
SMALLER TEAM LARGER TEAM
Life-cycle
phases
Weak boundaries between phases Well-defined phase transitions to synchronize
progress among concurrent activities
Artifacts Focus on technical artifacts
Few discrete baselines
Very few management artifacts
required
Change management of technical artifacts
resulting in numerous baselines
Management artifacts important
Workflow
effort
allocations
More need for generalists, people who
perform roles in multiple workflows
Higher percentage of specialists
More people and teams focused on a specific
workflow
Checkpoints Many informal events for maintaining
technical consistency
A few formal events
Synchronization among teams, which can take
days
Management
discipline
Informal planning, project control, and
organization
Formal planning, project control, and
organization
Automation
discipline
More ad hoc environments, managed
by individuals
Infrastructure to ensure a consistent, up-to-date
environment available across all teams
Additional tool integration to support project
control and change control
14.1.2 STAKEHOLDER COHESION OR CONTENTION
Specifics of the definition of a process are driven by the degree of cooperation and
coordination
among stakeholders – buyers, developers, users, subcontractors, and maintainers.
This process parameter can range from cohesive to adversarial.
Cohesive teams have common goals, complementary skills, and close communications.
Adversarial teams have conflicting goals, competing or incomplete skills, and less-than-
open
communications.
A product funded, developed, marketed, and sold by the same organization can be set up
with a
common goal, for example profitability.
A small, collocated organization can be established with cohesive skill base and excellent
day-today
communications among its team members.
A large contractual effort will have some contention across teams.
A contractor may not have all the necessary software or domain expertise and may have
to team
with multiple subcontractors, who have competing profit goals.
Funding authorities and users want to minimize cost, maximize the feature set, and
accelerate
time to market, while development contractors want to maximize profitability.
It is impossible to collocate large teams and synchronize stakeholder expectations.
All these factors tend to degrade team cohesion and must be managed continuously.
The following table summarizes key differences in the process primitives for varying
levels of
stakeholder cohesion:
TABLE 14-2. Process discriminators that result from differences in stakeholder

cohesion
PROCESS
PRIMITIVE
FEW
STAKEHOLDERS,
COHESIVE TEAMS
MULTIPLE STAKEHOLDERS, ADVERSARIAL
RELATIONSHIPS
Life-cycle
phases
Weak boundaries
between phases
Well-defined phase transitions to synchronize progress
among concurrent activities
Artifacts Fewer and less detailed
management artifacts
required
Management artifacts paramount, especially the
business case, vision, and status assessment
Workflow
effort
allocations
Less overhead in
assessment
High assessment overhead to ensure stakeholder
concurrence
Checkpoints Many informal events 3 or 4 formal events
Many informal technical walkthroughs necessary to
synchronize technical decisions
Synchronization among stakeholder teams, which can
impeded progress for weeks
Management
discipline
Informal planning,
project control, and
organization
Formal planning, project control, and organization
Automation
discipline
{Insignificant} On-line stakeholder environments necessary
14.1.3 PROCESS FLEXIBILITY OR RIGOR
The degree of rigor, formality, and change freedom inherent in a project’s contract –
vision
document, business case, and development plan – will have an impact on the
implementation of
the project’s process.
For loose contracts like building a commercial product within a business unit,
management
complexity will be minimal.
In these processes, feature set, time to market, budget, and quality can be freely traded off
and
change with very little overhead.
The entire coordination effort might involve only the development manager, marketing
manager,
and business unit manager coordinating some key commitments.
For very rigorous contracts, it could take months to authorize a change in a release
schedule.
To avoid a large custom development effort, it might be desirable to incorporate a new
commercial product into the overall design of a next-generation system.
This sort of change requires coordination among the development contractor, funding
agency,
users, certification agencies, associate contractors for interfacing systems, among others.
Large-scale, catastrophic cost-of-failure systems have extensive contractual rigor and
require
significantly different management approaches.
levels of
process flexibility/rigor.
TABLE 14-3. Process discriminators resulting from differences in process
flexibility/rigor
PROCESS PRIMITIVE FLEXIBLE PROCESS INFLEXIBLE PROCESS
Life-cycle phases Tolerant of cavalier phase
commitment
More credible basis required for
inception phase commitments
Artifacts Changeable business case
and vision
Carefully controlled changes to
business case and vision
Workflow effort allocations {Insignificant} Increased levels of management and
assessment workflows
Checkpoints Many informal events for
maintaining technical
consistency
3 or 4 formal events
synchronization among stakeholder
teams, which can impede progress
for days/weeks
Management discipline {Insignificant} More fidelity required for planning
and project control
Automation discipline {Insignificant} {Insignificant}
14.1.4 PROCESS MATURITY

The process maturity level of the development organization is another key driver of
management
complexity.
Managing a mature process [level 3 or higher] is simpler than managing an immature
process
[levels 1 and 2].
Organizations with a mature process have a high level of precedent experience in
developing
software and a high level of existing process collateral that enables predictable planning
and
execution of the process.
This sort of collateral includes well-defined methods, process automation tools, trained
personnel,
planning metrics, artifact templates, and workflow templates.
Tailoring a mature organization’s process for a specific project is a straightforward task.
levels of
process maturity:
TABLE 14-4. Process discriminators resulting from differences in process maturity
PROCESS
PRIMITIVE
MATURE (>= LEVEL 3) ORGANIZATION IMMATURE (LEVEL 1
OR 2) ORGANIZATION
Life-cycle phases Well-established criteria for phase transitions {Insignificant}
Artifacts Well-established format, content, and
production methods
Free-form
Workflow effort
allocations
Well-established basis No basis
Checkpoints Well-defined combination of formal and
informal events
{Insignificant}
Management
discipline
Predictable planning
Objective status assessments
Informal planning and
project control
Automation
discipline
Requires high levels of automation for roundtrip
engineering, change management, and
process instrumentation
Little automation or
disconnected islands of
automation
14.1.5 ARCHITECTURAL RISK
The degree of technical feasibility demonstrated before commitment to full-scale
production is
an important dimension of defining a specific project’s process.
There are man sources of architectural risk.
Some of the important and recurring sources are:
􀁿 System performance – resource utilization, response time, throughput, accuracy
􀁿 Robustness to change – addition of new features, incorporation of new technology,
adaptation to dynamic operational conditions
􀁿 System reliability – predictable behavior, fault tolerance
The degree to which these risks can be eliminated before construction begins has an
effect in the
process tailoring.
levels of
architectural risk:
PROCESS
PRIMITIVE
COMPLETE ARCHITECTURE
FEASIBILITY DEMONSTRATION
NO ARCHITECTURE
FEASIBILITY DEMONSTRATION
Life-cycle
phases
More inception and elaboration phase
iterations
Fewer early iterations
More construction iterations
Artifacts Earlier breadth and depth across
technical artifacts
{Insignificant}
Workflow
effort
allocations
Higher level of design effort
Lower levels of implementation and
assessment
Higher levels of implementation and
assessment to deal with increased scrap
and rework
Checkpoints More emphasis on executable
demonstrations
More emphasis on briefings, documents,
and simulations
Management
discipline
{Insignificant} {Insignificant}
Automation
discipline
More environment resources required
earlier in the life cycle
Less environment demand early in the
life cycle
14.1.6 DOMAIN EXPERIENCE

The development organization’s domain experience governs its ability to converge on an
acceptable architecture in a minimum number of iterations.
levels of
domain experience:
PROCESS
PRIMITIVE
EXPERIENCED TEAM INEXPERIENCED TEAM
Life-cycle phases Shorter engineering stage Longer engineering stage
Artifacts Less scrap and rework in requirements
and design sets
More scrap and rework in
requirements and design sets
Workflow effort
allocations
Lower levels of requirements and design Higher levels of requirements
and design
Checkpoints {Insignificant} {Insignificant}
Management
discipline
Less emphasis on risk management
Less-frequent status assessment needed
More-frequent status assessment
required
Automation discipline {Insignificant} {Insignificant}s
14.2 EXAMPLE:
SMALL-SCALE PROJECT VERSUS
LARGE-SCALE PROJECT
An analysis of the differences between the phases, workflows, and artifacts of two
projects on
opposite ends of the management complexity spectrum shows how different two software
project
processes can be.
The exercise is to point out the dimensions of flexibility, priority, and fidelity that can
change
when a process framework is applied to different applications, projects, and domains.
The following table illustrates the differences in schedule distribution of a small project –
example, 50,000 SLOC Visual Basic application, built by a team of five, and a large
project – a
3,00,000 SLOC embedded program, built by a team of 40.
TABLE 14-7. Schedule distribution across phases for small and large projects
ENGINEERING PRODUCTION
DOMAIN INCEPTION ELABORATION CONSTRUCTION TRANSITION
Small
commercial
project
10% 20% 50% 20%
Large, complex
project
15% 30% 40% 15%
The biggest difference is the relative time at which the life-cycle architecture milestone
occurs.
This corresponds to the amount of time spent in the engineering stage compared to the
production stage.
For a small project the split is 30/70 and for a large project, it is 45/55.
The leverage of the various process components in the success of the project is a key
aspect in
the differences between any two projects.
This reflects the importance of staffing or the level of associated risk management.
The following table lists the workflows in order of their importance:
TABLE 14-8. Differences in workflow priorities between small and large projects
RANK SMALL COMMERCIAL PROJECT LARGE, COMPLEX PROJECT
1 Design Management
2 Implementation Design
3 Deployment Requirements
4 Requirements Assessment
5 Assessment Environment
6 Management Implementation
7 Environment Deployment
The following list elaborates some of the key differences in discriminators of success:
The components, all, have relative importance, i.e. none of them is unimportant.
① Design is key in both domains.
Good design of a product is a key differentiator and is the foundation for efficient new
releases, and also for predictable, and cost efficient construction.
② Management is paramount in large projects, and less important in small projects.
In large projects, the consequences of planning errors, resource allocation errors,
inconsistent stakeholder expectations, and other out-of-balance factors can affect the
overall team dynamics.
In small projects opportunities for miscommunications are fewer and their consequences
less significant.
③ Deployment plays a greater role for a small product as there is a broad user base of
diverse individuals and environments.
A large, one-of-a-kind, complex project has a single deployment site.
Legacy systems and continuous operations may pose several risks, but these problems are
well understood and have a fairly static set of objectives. Another key set of differences is
inherent in the implementation of the various artifacts of the
process.
The following table provides a conceptual example of these differences:
TABLE 14-9. Differences in artifacts between small and large
projects
ARTIFACT SMALL COMMERCIAL
PROJECT
LARGE, COMPLEX PROJECT
Work breakdown
structure
1-page spreadsheet with 2
levels of WBS elements
Financial management system with 5
or 6 levels of WBS elements
Business case Spreadsheet and short
memo
3-volume proposal including technical
volume, cost volume, and related
experience
Vision statement 10-page concept paper 200-page subsystem specification
Development plan 10-page plan 200-page development plan
Release specifications
and number of releases
3 interim release
specifications
8 to 10 interim release specifications
Architecture
description
5 critical use case, 50 UML
diagrams, 20 pages of text,
other graphics
25 critical use cases, 200 UML
diagrams, 100 pages of text, other
graphics
Software 50,000 lines of Visual
Basic code
3,00,000 lines of C++ code
Release description 10-page release notes 100-page summary
Deployment User training course
Sales rollout kit
Transition plan
Installation plan
User manual On-line help and 100-page
user manual
200-page user manual
Status assessment Quarterly project reviews Monthly project management reviews
1) Explain the two primary dimension of process variability.
2) Discuss the major differences among project processes around the six process
parameters.
3) Explain the process discriminators resulting from differences in project size.
4) Explain the process discriminators resulting from differences in stakeholder cohesion.
5) Explain the process discriminators resulting from differences in process
flexibility/rigor.
6) Explain the process discriminators resulting from differences in process maturity.
7) Explain the process discriminators resulting from differences in architecture risk.
8) Explain the process discriminators resulting from differences in domain experience.
9) Illustrate the key differences between the phases, workflows, and artifacts of two
projects
on opposite ends of the management complexity spectrum.
PART – IV LOOKING FORWARD Page 133 of 187
CHAPTER-15 MODERN PROJECT PROFILES
There are five recurring issues of conventional projects, resolved by the modern process
framework exploiting several critical approaches: 1.Protracted integration and late
design breakage are resolved by forcing integration into the
engineering stage.
This is achieved through continuous integration of an architecture baseline supported by
executable demonstrations of the primary scenarios.
2.Late risk resolution is resolved by emphasizing an architecture-first approach, in which
the
high-leverage elements of the system are elaborated early in the life cycle.
3.The analysis phase paralysis of a requirements-driven functional decomposition is
avoided by
organizing lower level specifications along the content of releases rather than along the
product
decomposition by subsystem, by component, etc.
4.Adversarial stakeholder relationships are avoided by providing much more tangible
and
objective results throughout the life cycle.
5.The conventional focus on documents and review meetings is replaced by a focus on
demonstrable results and well-defined sets of artifacts, with more-rigorous notations and
extensive automation supporting paperless environment.
The following are the ways in which healthy modern projects resolve these five issues:
15.1 CONTINUOUS INTEGRATION
Iterative development produces the architecture first, allowing integration to occur as the
verification activity of the design phase and enabling design flaws to be detected and
resolved
earlier in the life-cycle.
This approach avoids the big-bang integration at the end of a project by stressing
continuous
integration throughout the project.
The figure above illustrates the differences between the progress profile of a modern
project and
that of a conventional project:
The architecture-first approach forces integration into the design phase through the
construction
of demonstrations.
The demonstrations don’t eliminate the design breakage; instead, they make it happen in
the
engineering stage, when it can be resolved efficiently in the context of life-cycle goals.
The down stream integration nightmare, late patches, and shoe-horned software fixes are
avoided.
The result is a more robust and maintainable design.
Conventional
Project Profile
100%
(% Coded)
Project Schedule
Iterative activities
Evolving management and engineering artifacts
Format
Activity
Product Prototypes Architecture Usable Releases Product Releases
Figure 15-1. Progress profile of a modern software project
project can avoid late
large-scale design
breakage through
continuous integration
The continuous integration of the iterative process also enables better insight into quality
tradeoffs.
System characteristics, largely inherent in the architecture – performance, fault tolerance,
maintainability – are tangible earlier in the process reducing the jeopardy in missing the
target
costs and schedules.
A recurring theme of successful iterative projects is a different cost profile.
The following table identifies the differences in modern process profile from the
perspective of
cost distribution among the various project workflows:
TABLE 15-1. Differences in workflow cost allocations between a
conventional
process and a modern process
SOFTWARE
ENGINEERING
WORKFLOWS
CONVENTIONAL
PROCESS
EXPENDITURES
MODERN
PROCESS
EXPENDITURES
Management 5% 10%
Environment 5% 10%
Requirements 5% 10%
Design 10% 15%
Implementation 30% 25%
Assessment 40% 25%
Deployment 5% 5%
Total 100% 100%
The primary discriminator of a successful modern process is inherent in the life-cycle
expenditures for assessment and testing.
Conventional projects, because of inefficient integration and late discovery of substantial
design
issues, expend about 40% or more of the total resources in integration and test activities.
Because of the mature iterative process, modern projects deliver require only about 25%
of the
total budget for these activities.
15.2 EARLY RISK RESOLUTION
The engineering stage – inception and elaboration phases – of the life cycle focuses on
confronting the risks and resolving them before the production stage.
Conventional projects do the easy stuff first, thereby demonstrating early progress.
A modern process takes up the important 20% of the requirements, use cases,
components, and
risks.
This is the essence of the principle of architecture first.
Defining the architecture does not include simple steps for which visible progress can be
achieved easily.
The effect of the 80/20 lessons learned in the past in software management experience
provide a
useful risk management perspective:
􀁀 80% of the engineering is consumed by 20% of the requirements.
Before committing resources to full-scale development, the driving requirements
complexity should be understood.
High fidelity and full traceability of the requirements should not be expected
prematurely.
􀁀 80% of the software cost is consumed by 20% of the components.
Elaborate the cost-critical components first so that planning and control of cost drivers
are well understood early in the life cycle.
􀁀 80% of the errors are caused by 20% of the components.
Elaborate the reliability-critical components first so that assessment activities have
enough time to achieve the necessary level of maturity.
􀁀 80% of the software scrap and rework is caused by 20% of the errors.
Elaborate the change-critical components first so that broad-impact changes occur when
the project is nimble or agile.
􀁀 80% of the resources – execution time, disk space, memory - are consumed by
20%
of the components.
Elaborate the performance-critical components first so that engineering trade-offs with
reliability, changeability, and cost-effectiveness can be resolved early in the life cycle.
􀁀 80% of the progress is made by 20% of the people.
The initial team for planning the project and designing the architecture should be of the
highest quality.
An adequate plan and adequate architecture can succeed with an average construction
team.
An inadequate plan or inadequate architecture will not succeed even with an expert
construction team.
The following figure compares the risk management profile of a modern project with the
profile
for a conventional project.
15.3 EVOLUTIONARY REQUIREMENTS
Conventional approaches decomposed
􀂾 system requirements into subsystem requirements ,
􀂾 subsystem requirements into component requirements, and
􀂾 component requirements into unit requirements
The organization of requirements was structured such that traceability is simple.
With an early life-cycle emphasis of requirements first, then complete traceability
between
requirements and design components, the natural tendency was for the design structure to
evolve
into an organization that paralleled the structure of requirements organization.
So, functional decomposition of the problem space led to a functional decomposition of
solution
space.
Modern architectures using commercial components, legacy components, distributed
resources,
and object-oriented methods are not easily traced to the requirements they satisfy.
There are complex relationships between requirements statements and design elements,
including 1 to 1, many to 1, 1 to many, conditional, time-based, and state-based.
Top-level requirements are retained as the vision.
Lower level requirements are captured in evaluation criteria attached to each intermediate
release.
These artifacts, illustrated in the following figure, are intended to evolve along with the
process,
with more and more fidelity as the life cycle progresses and requirements understanding
matures.
High
Low
Project Risk Exposure
Risk
Exploration
Period
Risk Elaboration
Period
Project Life Cycle
Inception Elaboration Construction – Transition
Controlled Risk
Management period
Conventional
Project Risk
Profile
Modern Project
Risk Profile
Figure 15-2. Risk Profile of a modern software project across its life cycle
So the fundamental difference from conventional requirements management approaches

is the
way fidelity is pursued early in the life cycle.
15.4 TEAMWORK AMONG STAKEHOLDERS
When stakeholder relationships degenerate into mutual distrust, it becomes difficult to
balance
requirements, product features, and plans.
An iterative process, with more-effective working relationships among stakeholders,
allows
trade-offs to be based on an objective understanding.
This process requires that customers, users, and monitors have both applications and
software
expertise, remain focused on the delivery of a usable system, and be willing to allow the
contractor to make a profit with good performance.
It also requires a development organization focused on achieving customer satisfaction
and high
product quality in a profitable manner.
The transition from the exchange of paper artifacts to demonstration of intermediate
results is
one of the crucial mechanisms for promoting teamwork among stakeholders.
Major milestones provide tangible results and feedback from a usage point of view.
The following table shows the results of major milestones in a modern process
TABLE 15-2. Results of major milestones in a modern process
APPARENT RESULT REAL RESULT
Early demonstrations expose design issues and
ambiguities in a tangible form
Demonstration expose the important assets and
risks of complex software systems early,
when they can be resolved within the
context of life-cycle goals
CAPABILITY
Fa Fb Fc
CAPABILITY
Fi Fj Fk
CAPABILITY
Fx Fy Fz
MECHANISMS
MECHANISMS
MECHANISMS
COMMON MECHANISMS
COMMON MECHANISMS
R1
R2
.
.
.
RN
Ra
Rb
.
.
.
Ri
Use Case
Model
FIGURE 15-3. Organization of software components resulting from a modern process
TABLE 15-2. Results of major milestones in a modern process (continued)

APPARENT RESULT REAL RESULT
The design is noncompliant Understanding of compliance matures from
important perspectives like architecturally
significant requirements and use cases
Driving requirements issues are exposed, but
detailed requirements traceability is lacking
Requirements changes are considered in
balance with design trade-offs
The design is considered “guilty until proven
innocent”
Engineering progress and issues tangible, for
incorporation into the next iteration’s plans
The above table shows, design are guilty until proven innocent: The project does not
progress
until the objectives of the demonstration are achieved.
This prerequisite includes the renegotiation of objectives after the demonstrations and
major
milestones results permit further understanding of the trade-offs inherent in the
requirements,
designs, plans, and technology.
There is a negative connotation in the above table: apparent results.
An iterative process focusing on demonstrable results requires all stakeholders to be
educated in
the important distinction between apparently negative results and evidence of real
progress.
For example, a design flaw discovered early, when the cost to resolve it is tenable, can be
viewed
as positive progress than as a major drawback.
15.5 TOP 10 SOFTWARE MANAGEMENT PRINCIPLES
1 Base the process on an architecture-first approach.
􀂾 An early focus on the architecture results in a solid foundation for the 20% of the effort
–
requirements, components, use cases, risks, and errors – that drives the overall success.
􀂾 Scrap and rework rates can be decreased or kept stable by getting the architecturally
important
components well understood before attempting the complete breadth and depth of the
artifacts.
2 Establish an iterative life-cycle process that confronts risk early.
􀂾 A dynamic planning framework with an iterative process results in better risk
management
and more predictable performance.
􀂾 Resolving the critical issues first implies a predictable construction phase and minimal
exposure to sources of cost and schedule unpredictability.
3 Transition design methods to emphasize component-based development.
􀂾 The complexity of a software effort is a function of number of human-generated
artifacts.
􀂾 Making the solution smaller reduces management complexity.
4 Establish a change management environment.
􀂾 The dynamics of iterative development, including concurrent workflows by different
teams
working on shared artifacts, necessitates objectively controlled baselines.
5 Enhance change freedom through tools that support round-trip engineering.
􀂾 Automation enables teams to spend more time on engineering and less time on
overhead taks.
􀂾 Round trip engineering is the environment support necessary to automate and
synchronize
engineering information in different formats like requirements specifications, design
models,
source code, executable code, test cases.
􀂾 Without substantial automation of the bookkeeping, change management,
documentation, and
testing, it is difficult to reduce iteration cycles to manageable time frames in which
change is
encouraged rather than avoided.
􀂾 Establishing an integrated environment is crucial to have change freedom, which is a
necessity in an iterative process.
6 Capture design artifacts in rigorous, model-based notation.
􀂾 An engineering notation for design enables complexity control, objective assessment,
and
automated analyses.
7 Instrument the process for objective quality control and progress assessment.
􀂾 Progress and quality indicators are derived directly from the evolving artifacts,
providing
more-meaningful insight into trends and correlation with requirements.
8 Use a demonstration-based approach to assess intermediate artifacts.
􀂾 Integration occurs early and continuously throughout the life cycle.
􀂾 Intermediate results are objective and tangible.
9 Plan intermediate releases in groups of usage scenarios with evolving levels of

detail.
􀂾 Requirements, designs, and plans evolve in balance.
􀂾 Useful software releases are available early in the life cycle.
10 Establish a configurable process that is economically scalable.
􀂾 Methods, techniques, tools, and experience can be applied straightforwardly to a broad
domain, providing improved return on investment across a line of business.
From all perspectives, the software project manager’s paramount objective is to maintain
proper
balance of emphasis across the 10 principles.
The following figure summarizes this balance theme in the context of fundamental
software
economics equation:
15.6 SOFTWARE MANAGEMENT BEST PRACTICES
One of the most visible efforts in capturing the best software management practices has
been the
Software Acquisition Best Practices Initiative by the U. S. Department of Defense to
“improve
and restructure our software acquisition management process.”
As per Brown’s summarization, the initiative has three components: the Airlie Software
Council
(of software industry gurus), seven different issue panels (of industry and government
practitioners), and a program manager’s panel (of experienced industry project
managers).
Each component produced recommendations and results, and reviewed the work of the
other
components.
One of the Airlie Software Council’s products was a set of nine best practices.
The Council focused on the practices that would have the greatest effect in improving the
software management discipline for large-scale software projects and controlling the
complexities therein.
The nine best practices are:
Cost = (Personnel) (Environment) (Quality) (Size)Process
Round-trip
engineering and
process instrumentation
improve the level of
automation and insight
into objective quality
control
Tackling the
architecture first
and change
management early
improves
achievable quality
Iterative and
configurable
processes improve
risk management
and process reuse
across multiple
projects
Evolving levels of
detail and a
demonstration-based
approach improve
communications among
stakeholders
Component-based
development and
model-based notation
help reduce the overall
size and complexity of
the solution
FIGURE 15-4. Balanced application of modern principles to achieve economic results
1. Formal risk management.

􀂾 Using an iterative process that confronts risk
2. Agreement on interfaces.
􀂾 The intent is: architecture-first principle.
􀂾 Getting the architecture baselined forces the project to again agreement on the external
interfaces – inherent in the architecture.
3. Formal inspections.
􀂾 The assessment workflow, along with the other engineering workflows, throughout the
life cycle must balance different defect removal strategies.
􀂾 The lowest important strategy, in terms of breadth, should be formal inspection, as it is
high on cost in human resources and low on defect discovery rate.
4. Metric-based scheduling and management.
􀂾 This is related to model-based notation and objective quality control principles.
􀂾 Without rigorous notations for artifacts, the measurement of progress and quality
degenerates into subjective estimates.
5. Binary quality gates at the inch-pebble level.
􀂾 Many projects have highly detailed plans laid out at a great expense, early in the life
cycle.
􀂾 Within a few months, some of the requirements change or the architecture changes,
and a
large percentage of the detailed planning must be re-baselined.
􀂾 A better approach would be to maintain fidelity of the plan commensurate with an
understanding of the requirements and the architecture.
􀂾 Rather than inch pebbles, establishing milestones in the engineering stage flowed by
inch
pebbles in the product stage is recommendable.
􀂾 This follows the evolving levels of detail principle.
6. Program-wide visibility of progress versus plan.
􀂾 Open communications among project team members is necessary.
7. Defect tracking against quality targets.
􀂾 This is related to architecture-first and objective quality control principles.
􀂾 The make-or-break defects and quality targets are architectural.
􀂾 Getting control on these qualities early and tracking their trends are requirements for
success.
8. Configuration management.
􀂾 The Council emphasized configuration management as key to controlling complexity
and
tracking changes to all artifacts.
􀂾 It also recognized that automation is important because of the volume and dynamics of
modern, large-scale projects.
􀂾 This reasoning follows the change management principle.
9. People-aware management accountability.
􀂾 This is another very obvious management principle.
Some important principles like configurability and component-based, model-based,
demonstration-based development, do not find place in the Council’s principles, though
these
principles aid in reducing complexity of development.
1) List the approaches of how a modern process framework resolves the drawbacks of
conventional approach. (P 225-226)
2) Compare and contrast how the project profiles differ between a conventional approach
and a modern process. (P 226-227)
3) Explain how risk resolution is carried out in the iterative processes early in the life
cycle,
and its advantages. (P 228-229)
4) Explain the organization of software components in a modern process, and thereby
how
teamwork among stakeholders helps in achieving better results. (P 229-231)
5) List out and explain the top 10 software management principles. (P 231-232)
6) Explain how balancing the top 10 software management principles achieves economic
results. (P231-233)
7) Discuss the Airlie Software Council’s nine best practices of software management;
also
explain how they are mapped onto the top 10 management principles. (P 232-235)
CHAPTER-16 NEXT-GENERATION SOFTWARE ECONOMICS
This chapter introduces several provocative hypotheses about the future of software
economics.
16.1 NEXT-GENERATION COST MODELS
Software experts have different opinions about software economics and its manifestation
in
software cost estimation models:
􀁿 Source line of code versus function points
􀁿 Productivity measures versus quality measures
􀁿 Java versus C++
􀁿 Object-oriented versus functionally oriented
􀁿 Commercial components versus custom development
A problem, today, is a continuing inability to predict with precision the resources
required for a
given software endeavor.
Accurate estimates are possible today, although they are imprecise.
It will be difficult to improve empirical estimation models when the data is noisy and
highly
uncorrelated, and is based on differing process and technology foundations.
There are no exactly matching cost models for an iterative software process focused on
an
architecture-first approach.
Many cost estimators still use a conventional process experience base to estimate a
modern
project profile.
The following discussion presents a perspective on how a software cost model should be
structured to support the estimation of a modern software process.
A next-generation software cost model should explicitly separate architectural
engineering from
application production.
The cost of designing, producing, testing, and maintaining the architecture baseline is a
function
of scale, quality, technology, process, and team skill.
An architecture cost model is inherently driven by research and development-oriented
concerns,
so some diseconomy of scale (exponent greater than 1.0), still exists.
For an organization having achieved a stable architecture, the production costs should be
an
exponential function of size, quality, and complexity, with a much more stable range of
process
and personnel influence.
The production stage cost model should reflect an economy of scale (exponent less than
1.0)
similar to that of conventional economic models.
The following figure summarizes a hypothesized cost model for an architecture-first
Next-generation software cost models should estimate large-scale architectures with
economy of
scale.
This implies, the process exponent during the production stage will be less than 1.0.
The reasons is, larger the system, more the opportunity to exploit automation and to reuse
common processes, components, and architectures.
In the conventional process, the minimal level of automation for the overhead activities
of
planning, project control, and change management led to labor-intensive workflows and a
diseconomy of scale.
This lack of automation was as true for multiple-project, line-of-business organization as
it was
for individual projects.
Next-generation environments and infrastructures are moving to automate and

standardize many
of these management activities, requiring a lower percentage of effort for overhead
activities as
scale increases.
Reusing common
􀁀 processes across multiple iterations of a single project,
􀁀 multiple releases of a single product, or
􀁀 multiple projects in an organization
relieves many of the sources of diseconomy of scale.
Critical sources of scrap and rework are eliminated by applying precedent experience and
mature
processes.
Establishing trustworthy plans based on credible project performance norms and using
reliable
components reduce other sources of scrap and rework.
Effort = F(TArch, SArch, QArch, PArch) + F(TApp, SApp, QApp, PApp)
Time = F(PArch, EffortArch) + F(PApp, EffortApp)
where:
T = technology parameter (environment automation support)
S = scale parameter (such as use cases, function points, SLOC)
Q = quality parameter (such as portability, reliability, performance)
P = process parameter (such as maturity, domain experience)
Engineering Stage
Production Stage
Risk resolution, low-fidelity plan
Schedule/technology-driven
Risk sharing contracts/funding
Low risk, high-fidelity plan
Cost-driven
Fixed-price contracts/funding
N-month design phase
M-month production increments
EffortArch E ffortApp
Size/Complexity Size/Complexity
PArch > 1.0 PApp < 1.0
Team Size [small and expert as possible]
Architecture: small team of software engineers
Applications: small team of domain engineers
Team Size [large and diverse as needed]
Architecture: small team of software engineers
Applications: as many as needed
Product
Executable architecture, production plans
Requirements
Product
Deliverable, useful function, Tested baselines
Warranted quality
Focus
Design and integration
Host development environment
Focus
Design and integration
Host development environment
Focus
Implement, test, and maintain
Target technology
Phases
Inception and elaboration
Phases
Construction and transition
FIGURE 16-1. Next-Generation cost models
Most reuse of components reduces the size of the production effort. The reuse of
processes, tools,
and experience has a direct impact on the economies of scale.
Another important difference is that architectures and applications have different units of
mass –
scale versus size, and are representations of the solution space.
Scale might be measured in terms of architecturally significant elements – classes,
components,
processes, nodes – and size might be measured in SLOC or MB of executable code.
These measures differ from measures of the problem spaces such as discrete requirements
or use
cases.
The problem space description drives the definition of the solution space.
There are many solutions to any given problem, as illustrated in the following figure,
each with a
different value proposition.
Cost is a key discriminator among potential solutions.
Cost estimates that are more accurate and more precise can be derived from specific
solutions to
problems.
So, the cost estimation model must be governed by the basic parameters of a candidate
solution.
If the value propositions are not acceptable solutions to the problem, more candidate
solutions
need to be pursued or the problem statement needs to change.
The debate between function point users and source line users is an indication of the need
for
measures of both scale and size.
Function points are more accurate at quantifying the scale of the architecture required,
and
SLOC is more accurate in depicting the size of components that make up total
implementation.
The advantage of using SLOC is that collection can easily be automated and precision
can be
easily achieved.
The accuracy of SLOC as a measure of size is ambiguous and can lead to
misinterpretation when
SLOC is used in absolute comparisons among different projects and organizations.
SLOC is a successful measure of size in the later phases of the life cycle, when the most
important measures are the relative changes from month to month as the project
converges on
releasable versions.
Problem Space
Units:
􀁀 Number of requirements
􀁀 Complexity of requirements
􀁀 Number of use cases
􀁀 Complexity of use cases
Solution N
Solution 2
Solution 1 Dimensions
􀁀 Features, F
􀁀 Qualities, Q
􀁀 Life-cycle savings, L
􀁀 Risk, R
􀁀 Schedule, S
􀁀 Cost, C
F+Q+L
􀁀 Value = ------------
R+S+C
Solution Space
FIGURE 16-2. Differentiating potential
solutions through cost estimation
The value of function points is that they are better at depicting the overall scale of the
solution,
independently of the actual size and implementation language.
Function pints are not easily extracted from any rigorous representation format, so
automation
and change tracking are difficult or ambiguous.
A rigorous notation for design artifacts is a necessary prerequisite to improvements in the
fidelity
with which the scale of a design can be estimated.
There will be an opportunity to automate, in the future, a new measure of scale derived
from
design representations in UML.
Two major improvements in next-generation software cost estimation models can be
expected:
1. Separation of the engineering stage from the production stage will force estimators to
differentiate between architectural scale and implementation size.
This will permit greater accuracy and more precision in life-cycle estimates.
2. Rigorous design notations such as UML will offer an opportunity to define units of
measure for scale that are more standardized and therefore can be automated and tracked.
These measures can also be traced more straightforwardly into the costs of production.
Technology advances are going to make two breakthroughs possible in the software
process:
1. The availability of integrated tools that automate the transition of information between
requirements, design, implementation, and deployment elements.
These tools allow comprehensive round-trip engineering among the engineering artifacts.
2. The current four sets of fundamental technical artifacts would collapse into three sets
by
automating the need for a separate implementation set.
This technology advance is illustrated in the following figure:
The technology advance would allow executable programs to be produced directly from
UML representations without any hand-coding.
The first breakthrough will be risky but straightforward.
The second one is a major paradigm shift.
When a software engineering team can produce implementation and deployment artifacts
in
an error-free, automated environment, the software development process can change
dramatically.
Requirements
Design
Implementatio
Deployment
Management
Requirements
Design
Implementatio
Deployment
Management
Requirements
Design
Deployment
Management
Documents On-line artifacts
Next-generation
environment
expectation
Software
Engineering
Experience
Conventional
Experience
All Engineering Engineering Separate
from Production
Engineering with
Automated Production
FIGURE 16-3. Automation of the construction process in next-generation
environments
16.2 MODERN SOFTWARE ECONOMICS

The framework arising out of Boehm’s top 10 software metrics can be used to summarize
some of the important themes in an economic context and speculate on how a modern
software management framework should perform.
The following are the expected changes. The organizational manager should strive for
these
changes in making the transition to a modern process.
1. Finding and fixing a software problem after delivery costs 100 times more than
finding
and fixing the problem in early design phases.
􀂌 Modern processes, component-based development technologies, and architecture
frameworks are explicitly target at improving this relationship.
􀂌 An architecture-first approach will yield tenfold to hundredfold improvement in the
resolution of architectural errors.
􀂌 So, the iterative process places a huge premium on early architecture insight and
riskconfronting
activities.
2. You can compress software development schedules 25% of nominal, but no more.
􀂌 This metric will be valid for the engineering stage of the life cycle because of the
intellectual content of the system.
􀂌 In the engineering stage, if a consistent baseline of architecture, construction plans, and
requirements is achieved, then schedule compression in production phase can be
flexible.
􀂌 Whether the engineering stage is spread over multiple projects [in line-of-business
organizations], or multiple increments [in project organization], there should be more
opportunity for concurrent development.
3. For every $1 you spend on development, you will spend $2 on maintenance.
􀂌 Generalizing this metric is difficult as there are different maintenance models.
􀂌 To measure this ratio, the productivity rates between development and maintenance
would be a better alternative.
􀂌 In iterative development, interestingly, the line between development and maintenance
is fuzzy.
􀂌 A mature process and a good architecture reduce scrap and rework considerably.
􀂌 All things considered the $1 to $2 ratio may turn out to $1 to $1.
4. Software development and maintenance costs are primarily a function of the
number
of SLOC.
􀂌 In today’s component based technology, SLOC as a size-metric is irrelevant.
􀂌 Commercial components reuse, and automatic code generators are all giving a new
meaning to a SLOC.
􀂌 The use of more components, more types of components, and more sources of
components necessitate more integration work and drive up costs.
􀂌 The component industry still being immature, standard bills of materials (costing) are
not available for improving the fidelity of its cost estimations.
􀂌 So, the next-generation cost models should be less sensitive to the number of SLOC
and more sensitive to the discrete number of components and their ease of integration.
5. Variations among people account for the biggest differences in software
productivity.
􀂌 For an engineering activity with intellectual property as the product, the dominant
productivity factors will be personnel skills, teamwork, and motivations.
􀂌 A modern process encapsulates the requirements for high-leverage people in the
engineering stage as the team size is relatively small.
􀂌 The production stage with larger team sizes, should operate with less dependency on
scarce expertise.
6. The overall ratio of software to hardware costs is still growing. In 1955, it was
15:85;
in 1985, 85:15.
􀂌 The main impact of this metric on software economics is that hardware continues to
get
cheaper.
􀂌 Processing cycles, storage, and network bandwidth continue to offer new opportunities
for automation.
􀂌 So, software environments are playing a more important role.
􀂌 In a modern process perspective, environment is doing more of the bookkeeping and

analysis activities, replacing the human beings.
􀂌 Configuration control and quality assurance analyses are already largely automated,
and
the next in the list are automated production and automated testing.
7. Only about 15% of software development effort is devoted to programming.
􀂌 In the last decade there has been shift away from investment in languages and
compilers.
􀂌 Modern technology investments have transitioned into process maturity (CMM), visual
modeling (UML), automated software quality (test automation), components (ActiveX,
CORBA, etc.), configuration management, metrics, and other aspects of software
engineering.
􀂌 The amount of programming is still about 15% only.
􀂌 Modern projects, as a difference, are programming at higher levels of abstraction.
􀂌 Programmer productivity in 90s produced tens of thousands of machine instructions
per
month, even though only a few hundred human-coded SLOC might have been
produced.
8. Software systems and products typically cost 3 times as much per SLOC as
individual
software programs. Software-system product (system of systems) cost 9 times as much.
􀂌 With a modern process and modern technologies this diseconomy could be largely
corrected.
􀂌 Common architectures, common environments, and common processes could make it
possible to achieve economies of scale.
9. Walkthroughs catch 60% of errors.
􀂌 Human inspections do not expose critical issues; they only help in resolving them.
􀂌 The environment catches most of the first-level inconsistencies and errors.
􀂌 The important architectural issues can be exposed only through demonstrations and
early testing and resolved through human scrutiny.
10. 80% of the contribution comes from 20% of contributors.
􀂌 This postulate is timeless.
􀂌 It is the background philosophy applicable throughout the planning and conduct of
software management process.
1. Propose and explain a general structure for a cost estimation model for the modern
software process. [P 237-238, Fig. 16-1/P 239]
2. Compare and contrast a cost estimation model for the modern process with that of the
conventional process. [P 239-241, Fig. 16-2/P 240]]
3. Explain the possible improvements in the next-generation cost estimation models over
the conventional ones. [P 241-242, Fig. 16-3/P 242]
4. Discuss the modern software economics keeping Boehm’s top 10 software metrics as a
framework. [P 242-245]
CHAPTER-17 MODERN PROCESS TRANSITIONS
Technical breakthroughs, process breakthroughs, and new tools will make software
management
easier.
Management discipline will remain to be the backbone for project success.
New technology means:
♥ New opportunities for software applications,
♥ New dimensions of complexity,
♥ New avenues of automation, and
♥ New customers with new/different priorities
Accommodating these changes will require changes in the
traditional/ingrained/established
software management priorities and principles.
Striking a balance among requirements, designs, and plans will remain the main objective
of
software management efforts.
Many of the techniques and disciplines required for a modern process will necessitate a
significant paradigm shift.
As usual, changes will be resisted by some stakeholders or certain intra-organizational
factors.
It is important, equally, to separate cultural resistance from objective resistance.
In this chapter we consider the important culture shifts to be prepared for in order to
avoid the
sources of friction in transitioning to and practicing a modern process.
17.1 CULTURE SHIFTS
The following are the indicators to look for in order to differentiate project that have
made a
genuine cultural transition from project that have only put up a façade:
􀀩 Lower level and mid-level manger are performers.
􀀌 The need for “pure managers” arises only when personnel resources exceed the level
of
more than 25 people.
􀀌 Competent managers spend their time performing, especially with regard to
understanding the status of the project firsthand and developing plans and estimates.
􀀌 The person managing an effort should plan it.
􀀌 The manager should participate in, and not approve, developing the plan.
􀀌 A good indicator of trouble is a manager who did not author the plan or did not take
own it.
􀀌 The stakeholders affected by this transition are the software project managers.
􀀩 Requirements and design are fluid and tangible.
􀀌 An iterative process requires actual construction of a sequence of progressive
comprehensive systems that demonstrate the architecture, enable objective
requirements negotiations, validate the technical approach, and address resolution of
key risks.
􀀌 All stakeholders would be focused on these “real” milestones, with incremental
deliveries of useful functionality than speculative paper descriptions.
􀀌 The transition to a less document-driven environment will be followed by the
engineering teams; and resisted by traditional contract monitors.
􀀩 Ambitious demonstrations are encouraged.
􀀌 Early life-cycle demonstrations should be used for exposing design flaws, and not as a
show-off.
􀀌 Stakeholders should not overreact to early mistakes, digressions, or immature designs.
􀀌 Otherwise, organizations will set up future iterations to be less ambitious.
􀀌 In early release plans evaluation criteria are to be taken as goals, and not as
requirements.
􀀌 At the same time, lack of follow-through should not be tolerated.
􀀌 Negative trends, not resolved with rigor, may become serious downstream
perturbations.
􀀌 Open and attentive follow-through is necessary to resolve issues.
􀀌 If the management team resists this transition, it implies some engineering or process
issues are being hidden.
􀀩 Good and bad project performance is much more obvious earlier in the life cycle.
􀀌 Success breeds success.
􀀌 Early failures are risky to turn around or difficult to solve downstream.
􀀌 It is the early phases that make or break a project.
􀀌 So, they very best team should perform the planning and architecture phases.
􀀌 Then, projects can be completed successfully even with average teams.
􀀌 Otherwise, all the expert programmers and testers may not be able to achieve success.
􀀌 Early staffing with the right team should not be resisted.
􀀩 Early increments will be immature.
􀀌 External stakeholders – customers and end-users – cannot expect initial deliveries to
perform up to specifications, to be complete, to be fully reliable, or to have end-target
levels of quality or performance.
􀀌 Development organizations must demonstrate tangible improvement in successive
increments in a responsible way.
􀀌 The trends will indicate convergence toward specification.
􀀌 Objectively quantifying changes, fixes, and upgrades will indicate the quality of the
process and environment for future activities.
􀀌 Management and the development team will accept immaturity as a natural part of the
process, as long as the customers are impressed by later increments even when the early
flaws are difficult to be happy about.
􀀩 Artifacts are less important early, more important later.
􀀌 A baseline should be achieved that is useful and stable to warrant time-consuming
analyses of the quality factors of traceability, thoroughness, and completeness.
􀀌 Until the baseline is achieved the details need not be considered.
􀀌 Otherwise, early engineering cycles and resources will be wasted in adding content and
quality to artifacts which would soon be obsolete.
􀀌 The development team will embrace this transition.
􀀌 The traditional contract monitors will resists the early de-emphasis on completeness.
􀀩 Real issues are surfaced and resolved systematically.
􀀌 Requirements and designs evolve together, with continuous negotiation, trade-off, and
bartering toward best value.
􀀌 This should be recognized for the success of a project.
􀀌 The difference between real and apparent issues can easily be spotted on healthy
projects.
􀀌 This culture shift could affect almost any team.
􀀩 Quality assurance is everyone’s job, not a separate discipline.
􀀌 Surfacing of early performance issues is a sing of an immature design but a mature
design process.
􀀌 Stakeholders will be concerned over early performance issues.
􀀌 Development engineers will emphasize on early demonstrations and the ability to
assess and evaluate performance trade-offs in subsequent releases.
􀀌 Quality assurance should be part of every role, every activity, and every artifact.
􀀌 Quality assurance is measured by tangible progress and objective data, not by
checklists,
meetings, and human inspections.
􀀌 The person responsible for the design or management should ensure that quality
assurance is integrated into the process.
􀀌 Inspections by separate team as in the traditional process are replaced by self-assuring
teamwork of an organization with a mature process, common objectives, and common
incentives.
􀀌 The development team will embrace this transition.
􀀌 The traditional contract monitors will resists the early de-emphasis on completeness.
􀀩 Performance issues arise early in the life cycle.
􀀌 On every successful project, early performance issues arise.
􀀌 These issues are a sign of an immature design but a mature design process.
􀀌 Management and the development team will accept immaturity as a natural part of the
process, as long as the customers are impressed by later increments even when the early
flaws are difficult to be happy about.
􀀩 Investments in automation are necessary.

􀀌 Iterative development projects require extensive automation. So, underinvestment in
the
capital environment is not desirable.
􀀌 The stakeholders also should acquire an integrated environment to be able to
efficiently
participate in an iterative development.
􀀌 Else, interactions become, like in traditional process, paper-oriented.
􀀌 These investments may be resisted by managers focused on near-term financial results
or by personnel with preference of the individual project over the global solution that
serves both the project and the organization goals.
􀀩 Good software organization should be more profitable.
􀀌 In the commercial software domain, this is not an issue.
􀀌 In the software contracting domain it is an issue.
􀀌 Generally, there is focus on ensuring that contractor profits are within an acceptable
range of 5% to 15%.
􀀌 Excellent contractor performance, good value engineering, or significant reuse results
in profit margins being higher.
􀀌 In such cases, there may be pressure from the external stakeholders to apply these
“excess” resources to out-of-scope changes to off-set the margin back to acceptable
range.
􀀌 This results in the profit motive being replaced by complex contractual incentives and
producer-consumer conflicts that are sub-optimal.
􀀌 The contractors will not take any risks nor do they use cost-saving techniques.
􀀌 So large amounts will be spent without getting any result and with no accountability
for
poor performance.
17.2 DENOUEMENT
The conventional software process was characterized by:
􀀯 Sequentially transitioning from requirements to design to code to test
􀀯 Achieving 100% completeness of each artifact at each life-cycle stage
􀀯 Achieving high-fidelity traceability among all artifacts at teach stage in the life cycle
A modern iterative development process framework is characterized by:
☺ Continuous round-trip engineering from requirements to test at evolving levels of
abstraction
☺ Achieving high-fidelity understanding of the drivers as early as practical
☺ Evolving the artifacts in breadth and depth based on risk management priorities
☺ Postponing completeness and consistency analyses until later in the life cycle
A modern process framework attacks the primary sources of the diseconomy of scale of
the
conventional software process.
The following figure illustrates the next generation of software project performance
depicting the
development progress versus time:
Range of
domainreusable
assets
Modern
Project Profile
Conventional
Project Profile
Project Schedule
(% coded)
100%-
FIGURE 17-1. Next-generation project performance
In the above figure, progress is defined as percent coded – demonstrable in its target
form.
Organizations that succeed should be capable of deploying software products that are
constructed
largely from existing components in 50% less time, with 50% fewer development
resources, and
maintained by teams 50% the size of these required by the systems.
To avoid the apprehension of failure due to the transitioning to new techniques and
technologies,
a safe path is to maintain the status quo and rely on existing methods.
But for higher success, maintaining the status quo is not always safe.
To make a transition, two points of wisdom from champions and change agents are:
1. Pioneer any new techniques on a small pilot program, and
2. Be prepared to spend more resources – money and time – on the first project that
makes
the transition.
But both the recommendations are counter-productive.
Small pilot programs rarely achieve any paradigm shift of consequence.
Trying a new technique, tool, or method on a very rapid, small-scale effort can show
good results,
initial momentum, or proof of concept.
But pilot projects are never on the critical path of the organization.
So, the best teams, adequate resources, or management attention may not be allocated to
them.
Organizational paradigm shifts result from the circumstances when:
Most critical project is taken up with the highest caliber personnel, allocated them
adequate
resources, and demanding better results
An organization expects a new method, tool, or technology to have an adverse impact on
the
results of an innovative project, and it comes true only when it is a non-critical project
and
adequate resources are not allocated to it.
A better way to transition to a more mature iterative development process that supports
automation technologies and modern architectures is to:
Ready. Do your homework.
Analyze modern approaches and technologies
Define/improve/optimize the process
Support it with mature environments, tools, and components
Plan thoroughly
Aim. Select a critical project
Staff it with the right team, adequate resources, and demand improved results
Fire. Execute the organizational and project-level plans with vigor and follow-through.
1. List out and explain the culture shifts to be overcome while transitioning to modern
processes. [P 248-251]
2. Explain the issues in transitioning from conventional practices to modern iterative
methods, with reference to performance and the strategies to be adopted for transitioning.
[P 251-253, Fig 17-1/P 252]
PART – V CASE STUDIES AND BACKUP MATERIAL Page 150 of 187
APPENDIX D CCPDS-R CASE STUDY
This appendix presents a detailed case study of a successful software project.
The success, here, is in terms of on-budget, on-schedule, and customer-satisfaction.
The COMMAND CENTER PROCESSING and DISPLAY SYSTEM-REPLACEMENT
(CCPDS-R) project was performed for the U. S. Air Force by TRW Space and Defense in
Redondo Beach, California.
The project included: systems engineering, hardware procurement, and software
development.
These three components consumed 1/3 of the budget.
The schedule spanned 1987 to 1994.
The software effort included the development of three distinct software systems of more
than one
million SLOC.
This case study focuses on the initial software development, called the Common
Subsystem of
about 3,55,000 SLOC.
The Common Subsystem effort also produced a reusable architecture, a mature process,
and an
integrated environment for efficient development of the two software subsystems of
similar size
that followed.
So, this case study represents about 1/6 of the overall CCPDS-R project effort.
D.1 CONTEXT FOR THE CASE STUDY
The data, given here, are derived from published papers, internal TRW guidebooks, and
contract
deliverable documents.
D.2 COMMON SUBSYSTEM OVERVIEW
The CCPDS-R project produced a large-scale, highly reliable command and control
system that
provides missile warning information used by the National Command Authority.
The procurement agency was Air Force Systems Command Headquarters, Electronic
Systems
Division, at Hanscom Air Force Base, Massachusetts.
The primary user was US Space Command, and the full-scale development contract was
awarded
to TRW’s Systems Integration Groups.
The CCPDS-R contract called for the development of three subsystems:
1. The Common Subsystem was the primary missile warning system within the upgrade
program.
􀂾 3,55,000 SLOC
􀂾 48-month software development schedule
􀂾 provided reusable components, tools, environment, process, and procedures for
the following subsystems
􀂾 included a primary installation with a backup system
2. The Processing and Display Subsystem (PDS) was a scaled-down missile warning
display system for all nuclear-capable commanders-in-chief.
􀂾 2,50,000 SLOC
􀂾 fielded on remote, read-only workstations distributed worldwide
3. The STRATCOM Subsystem provided both missile warning and force management
capability for the backup missile warning center.
􀂾 4,50,000 SLOC
Overall Software Acquisition Process
The CCPDS-R acquisition included two distinct phases:
① A concept definition (CD) phase, and
② A full-scale development (FSD) phase
The following figure summarizes the overall acquisition process and the products of each
phase:
The CD phase was similar, in intent, to the inception phase:
The primary products were:
♥ A system specification document – vision document
♥ An FSD phase proposal – a business including technical approach and a fixed-price-
incentive
and award-fee cost proposal
♥ A software development plan
♥ A system design review
♥ Technical interchange meetings with the stakeholders – customer and user
♥ Several contract-deliverable documents
These event and products enabled the FSD source selection to be based on demonstrated
performance of the contractor-proposed team and the FSD proposal.
From the software perspective a source selection criterion included in the FSD proposal
activities:
a software engineering exercise.
This was a unique and effective approach for assessing the abilities of the competing
contractors
in software development.
The customer was concerned with the overall software risk of the project.
CCPDS-R was a large software development activity and one of the first to use the Ada
programming language.
There was apprehension about the Ada development environments, contractor processes,
and
contractor training programs being mature enough to use on a full-scale development
effort.
The software engineering exercise was intended to demonstrate these apprehensions.
The software engineering exercise occurred immediately after the FSD proposals were
submitted.
The customer provided the bidders with a simple two-page specification of a “missile
warning
simulator” with some of the same fundamental requirements as the CCPDS-R system.
It included a distributed architecture, a flexible user interface, and the basic processing
scenarios
of a simple CCPDS-R missile warning thread.
CD phase
Schedule:
12 months
Products:
Vision
Business case
Software development plan
Software engineering exercise
Contract:
Firm fixed price
ISRR: Initial System Requirements
Review
ISDR: Initial System Design
Review
Competitive Design Phase
(Inception)
ISRR ISDR
FSD phase
Schedule:
48 months
Products:
2167A software document
Six software configuration items
Major milestones
Beta delivery (EOC)
Contract:
Firm fixed price award fee
SRR: System requirements review
IPDR: Interim Preliminary design review
PDR: Preliminary design review
CDR: Critical design review
EOC: Early operational capability
FQT: Final qualification test
Full-Scale Development Phase
(Elaboration – Construction – Transition)
SRR IPDR PDR C DR EOC FQT
FIGURE D-1. CCPDS-R life-cycle overview
The requirements of the software engineering exercise included:

􀀩 Use the proposed software team
􀀩 Use the FSD-proposed software development techniques and tools
􀀩 Use the FSD-proposed software development plan
􀀩 Conduct a mock design review with the customer
The exercise was to provide objective evidence of the credibility of each contractor’s
proposed
software development approach.
The TRW’s CCPDS-R team demonstrated that the team was prepared, credible, and
competent
at conducting the proposed software approach.
This took 12 staff-months – 12 people full-time for 23 days.
A detailed plan was established including
♥ An activity network
♥ Responsibility assignments
♥ Expected results for tracking progress
♥ Two architecture iterations
♥ Milestones and artifacts proposed in the software development plan
The exercise produced the following results:
􀀈 Four primary use cases were elaborated and demonstrated
􀀈 A software architecture skeleton was designed, prototyped, and documented with
􀀈 two executables
􀀈 distributed processes
􀀈 Five concurrent tasks with
􀂃 separate threads of control
􀀈 eight components
􀀈 72 component-component interfaces
􀀈 4,163 SLOC of prototype components were developed and executed
􀀈 several thousand lines of reusable components were integrated into the
demonstration
􀀈 Three milestones were conducted and more than 30 action items resolved
􀀈 Production of 11 documents – corresponding to the proposed artifacts to demonstrate
the
inherent automation of the documentation tools
􀀈 The Digital Equipment Corporation VAX/VMS tools, Rational R1000 environment,
LaTeX documentation templates, and several custom-developed tools were used
􀀈 Improvements to the process and the tools were identified
􀀈 The concept of evolving the plan, requirements, process, design and environment
at each major milestone was considered potentially risky, but
􀀈 Implemented with rigorous change management
TRW proposed an architecture-first, demonstration-based approach and demonstrated its
operational concept successfully under realistic, small-scale and accelerated conditions.
D.3 PROJECT ORGANIZATION
In preparing for the CCPDS-R project, TRW placed a strong emphasis on evolving the
right
team.
The CD-phase team represented the architecture team, responsible for an efficient
engineering
stage.
This team had the following primary responsibilities:
􀀊 Analyze and specify the project requirements
􀀊 Define and develop the top-level architecture
􀀊 Plan the FSD phase software development activities
􀀊 Configure the process and development environment
􀀊 Establish trust and win-win relationships among the stakeholders
The CD phase team was small, expert, and with little organizational hierarchy.
The team covered all necessary skills, and with no competition among personnel.
D.4 COMMON SUBSYSTEM PRODUCT OVERVIEW

The Common Subsystem software comprised six computer software configuration items
(CSCIs).
[CSCI is a government jargon for a set of components that is managed, configured, and
documented as a unit and allocated to a single team for development].
The CSCIs were identified as follows:
1. NAS – Network Architecture Services. This foundation middleware provided reusable
components for network management, interprocess communications, initialization,
reconfiguration, anomaly management, and instrumentation of software health,
performance, and state.
This CSCI was designed to be reused across all three CCPDS-R subsystems.
2. SSV – System Services. This CSCI comprised the software architecture skeleton,
realtime
data distribution, global data types, and the computer system operator interface.
3. DCO – Display Coordination. This CSCI comprised user interface control, display
formats, and display population.
4. TAS – Test and Simulation. This CSCI comprised test scenario generation, test
message
injection, data recording, and scenario playback.
5. CMP – Common Mission Processing. This CSCI comprised the missile warning
algorithms for radar, nuclear detonation, and satellite early warning messages.
6. CCO – Common Communications. This comprised external interfaces with other
systems
and message input, output, and protocol management.
The following table summarizes the distinguishing characteristics of each CSCI:
TABLE D-1. CSCI summary
CSCI SIZE
(SLOC)
COMPLEXITY ASSETS (+) and CHALLENGES (-)
NAS 20,000 Very high + Experienced, superior team
+ Second generation product
- Reusable across subsystems
- High performance reliable
SSV 1,60,000 High + Some tool produced code
+ Stable NAS primitives
- Numerous global interfaces, types, components
DCO 70,000 Moderate + Flexible display design
+ Tool-produced formats
- Tough performance requirement
- Continuous change
TAS 10,000 Low + Simple application
+ Some off-line processing
- Offsite team
- Limited environment resources
CMP 15,000 Moderate + Domain experience
+ Straightforward processing
- Offsite team
- Stringent performance requirements
- Many stakeholders involved in approving algorithm
design
CCO 80,000 High + Skilled people
+ Precedent domain experience
- Stringent performance requirements
- Unstable external interface
Total 3,55,000 High Large scale, high performance, high reliability
The Software Architecture Skeleton
The CCPDS-R software process was tailored to exploit Ada and reusable middleware
components to construct a distributed architecture rapidly.
The NAS CSCI provided these primitive components.
These components – a first-generation middleware solution – enabled a true component-
based
development approach to distributed architectures.
The instantiation of the NAS generic tasks, processes, sockets, and circuits into a run-
time
infrastructure was called a software architecture skeleton (SAS).
The software engineering associated with the Common Subsystem SAS was the focus of
early
builds and demonstrations – an example of architecture-first process.
The SAS encompasses the declarative view of the solution, including all the top-level
control
structures, interfaces, and data types passed across these interfaces.
In the CCPDS-R definition of an architecture, the declarative view included the
following:
♦ All Ada main programs
♦ All Ada tasks and task attributes
♦ All socket (asynchronous task-to-task communications), socket attributes, and
connections to
other sockets
♦ Data types for objects passed across sockets
♦ NAS components for
Even though a SAS will compile, it executes many scenarios only after software is added
that
reads messages, processes them, and writes them within application tasks.
The purpose of a SAS is to provide the structure and interface network for integrating
components into threads of capability.
There are two aspects of SAS verification and assessment: (1) compilation, and (2)
execution.
Construction and compilation of all the SAS objects together is a non-trivial assessment
that
provides feedback about the consistency and quality of the SAS.
Constructing the components and executing the stimuli and response threads within the
SAS
provide further feedback about structural integrity and run-time semantics.
Then, the SAS provides the forum for integration and architecture evolution.
Construction of SAS early helps in evolving it into a stable baseline in which change is
managed
and measured for feedback about architectural stability.
CCPDS-R installed its first SAS baseline – after three informal iterations, around month
13,
before the PDR milestone.
All subsequent changes was performed via rigorous configuration control.
The changes SAS underwent after its first baseline were scrutinized. The SAS dynamics
converged on an acceptable architecture with solid substantiation early in the life cycle.
So the SAS was useful in assessing the volatility in the overall software interfaces and
captured
the conceptual architecture of the Common Subsystem.
The following figure provides a perspective of the software architecture stability:
The graphs in the figure show that there was significant architectural change over the first
20
months of the project, after which the architecture remained stable.
o Initialization
o State management of
process and tasks
o Fault handling
o Interprocess
communications
o Health and performance
monitoring
o Instrumentation
o Network management
o Logging
o Network control
-200
-100
IPDR PDR
65
Processes
Months
-500
-250
IPDR PDR
251
Tasks
Months
-1500
-750
IPDR PDR
Sockets
Months
1,148
IPDR PDR
Message Types
Months
-500
-250 200
FIGURE D-3. Common Subsystem SAS evolution
The large spike in processes and tasks around month 5 corresponded to an attempt at a
more
distributed approach. As this architecture experimentation exposed the design trade-offs
in
distribution strategies, the SAS process design was changed back to the original number
of
processes. The SAS task-level design converged on an increased number of tasks.
The basic problems being examined by the architecture team were the trade-offs in
concurrency,
operating system process overhead, run-time library tasking overhead, paging, context
switching,
and the mix of interprocess, inter-task, and inter-node message exchange.
The complexity of such run-time interactions made modeling and simulation ineffective.
Only the early run-time demonstrations of multiple distribution configurations allowed
the
architecture team to achieve the understanding of technical trade-offs necessary to select
an
adequate solution.
If the change in the distribution design occurred late in the project, the impact could have
been
immense.
Because sockets and messages were simple to change and corresponded to lower level
application interfaces, changes to these numbers continued at a low level through the
critical
design review (CDR) milestone.
This experimentation helped in the achievement of an architecture baseline early in the
life cycle.
This was enabled by the flexibility of the NAS CSCI.
D.5 PROCESS OVERVIEW
CCPDS-R software development followed a Department of Defense life cycle with a
software
requirement review, preliminary design review, critical design review, and final
qualification test.
Building
blocks
Building
blocks
Critical
threads
Non-critical
threads
Completeness:
maturation, tuning
Requirements analysis
Architecture analysis
Architecture synthesis
Critical-thread demonstration
Architecture maintenance
Application construction
Architecture maintenance
Application maintenance
Inception Inception Construction
CD Phase Contract
award
SRR IPDR PDR CDR FQT
SRR
Demo
Build 0 and
IPDR Demo
Build 1 and
PDR Demo CDR
Demo
0 5 9 14 24 Months after 45
Contract award
Primitives and
support software
Architecture, test
scenarios, models
Critical thread algorithms,
applications, displays
Non-critical thread algorithms,
applications, displays
Communications interfaces,
final test scenarios
Associate contractor interface
Build 0
Build 1
Build 2
Build 3
Build 4
Build 5
Build 2
Build 3-1
Build 3-2
Build 4 Build 5
FIGURE D-4.
Overview of
the CCPDS-R
macroprocess,
milestone, and
schedule
The figure above illustrates the mapping of the life cycles of the design phase and full-
scale
development phase to the phases of the iterative process framework:
In all six incremental builds were defined to manage the project.
The figure above summarizes the build content and overlap.
The conclusion of each build corresponded to a new baseline of the overall Common
Subsystem.
From a macroprocess view, the initial milestones focused on achieving a baseline
architecture.
The PDR baseline required three major architecture iterations:
1. The Software Requirements Review (SRR) demonstration: initial feasibility of the
foundation components and basic use cases of initialization and interprocess
communications
2. The Interim Preliminary Design Review (IPDR) demonstration: the feasibility of the
architecture infrastructure under the riskiest use cases, including the following:
♦ A peak data load missile warning scenario of a mass raid
♦ A peak control load scenario of a system failover and recovery from the primary thread
of processing to a backup thread with no loss of data
3. The Preliminary Design Review (PDR) demonstration: adequate achievement of the
peak
load scenarios and the other primary use cases within a full-scale architectural
infrastructure, including the other critical-thread components
The CDR demonstration updated the architecture baseline.
This was equivalent to an alpha test for the complete architectural infrastructure and the
criticalthread
scenarios.
By providing a set of complete use cases it enabled the user to perform a subset of the
mission.
The CCPDS-R software process had a well-defined macroprocess.
Each major milestone was accompanied by a major demonstration of capability with
contributions from on-going builds.
The design process used was more incremental than iterative, although, it was clearly
both.
D.5.1 RISK MANAGEMENT: BUILD CONTENT
Planning the content and schedule of the Common Subsystem builds resulted in a useful
and
accurate representation of the overall risk management plan.
The build plan was thought out early in the inception phase by the management team.
The management team set the expectation for reallocating build content as the life cycle
progressed and more-accurate assessments of complexity, risk, personnel, and
engineering tradeoffs
were achieved.
There were several adjustments in the build-content and schedule as early conjecture
evolved
into objective fact.
The following figure illustrates the detailed scheduled and CSCI content of the Common
Subsystem:
FIGURE D-5(a). Common Subsystem builds (Part – 1)
CSCI Build
0 1 2 3 4 5 Total
NAS 8 8 2 2 20
SSV 33 25 102 106
DCO 23 27 20 70
TAS 2 3 5 10
CMP 3 6 6 15
CCO 5 31 37 7 80
Totals
8
43
61
173
63
7
355
The details of the build content of the Common Subsystem are:
♦ Build 0. This build comprised the foundation components necessary to build a software
architecture skeleton.
The inter-task/interprocess communications, generic task and process executives, and
common error reporting components were included.
This build was also the conclusion of the research and development projected executed in
parallel with the CD [inception] phase.
These NAS components were the cornerstone of the architectural framework and were
built
to be reusable by all the CCPDS-R subsystems.
They represented very complex, high-risk components with stringent performance,
reliability, and reusability demands.
♦ Build 1. This was essentially the “architecture.”
It included a complete set of instantiated tasks [300], processes [70], interconnections
[1000],
states, and state transitions for the structural solution of the CCPDS-R software
architecture.
All the NAS components for initialization, state management (configuration), and
instrumentation were added to achieve a cycling architecture.
To support the initial demonstration, a trivial user interface and test scenario injection
capability were also added.
Upon completion of this build, only a few critical use cases were demonstrable:
initializing
the architecture, injecting a test scenario to drive the data flow through the system, and
orchestrating reconfigurations such as primary thread switchover to backup thread.
♦ Build 2. First build of mission-critical components and achieved the initial capability to
execute real mission scenarios.
The three primary risks in the mission scenarios were: the timeliness of the display
database
distribution, the performance (resource consumption and accuracy) of the missile
warning
radar algorithms, and the performance of the user interface for several complex displays.
Upon completion of this build, several mission-oriented use case could be executed,
including the worst-case data processing thread and the worst-case control processing
thread
– primary-to-backup switchover.
♦ Build 3. This build contained the largest volume of code, including display format
definitions,
global type definitions, and representation specifications needed for validation of external
interface transactions.
Most of the voluminous code was generated automatically in a cookbook manner by
constructing code generation tools.
Build 0
􀁓PDW 􀁓CDW 􀁓􀁓TOR
Build 1
􀁓PDW 􀁓CDW 􀁓􀁓T0R
Development Stand-alone test
􀁓
Turnover for
configuration control
Build 2
Build 3
􀁓PDW 􀁓CDW 􀁓TOR1 􀁓􀁓TOR2
Build 4
Build 5
||||||||
0 5 10 15 20 25 30 34
􀁓SRR 􀁓IPDR 􀁓PDR 􀁓CDR
PDW: Preliminary Design Walkthrough
CDW: Critical Design Walkthrough
TOR : Turnover Review
􀁓Original milestone
FIGURE D-5(b). Common Subsystem builds (Part – 2)
KSLOC
8
43
61
173
83
7
355
Months after contract award
The external communications interface protocol handling, the completed user-system

interface for the computer support positions, the system services for mission
reconfigurations,
database resets, off-line data reduction, and the nuclear detonation algorithms were the
other
remaining components allocated to this build.
Because of the volume of the build, it was implemented as builds 3-1, and 3-2.
♦ Build 4. This build provided the final installment of missile warning algorithms for
satellite
early warning systems, the final installment of mission management and mission status
displays, and the final installment of external communications interface processing.
♦ Build 5. This build was added, in the middle of the Common Subsystem schedule, to
coincide with a particular external interface,
The schedule for which had slipped beyond the timely availability.
Consequently, the external interface was scheduled into an entirely new build.
D.5.2 THE INCREMENTAL DESIGN PROCESS
The individual milestones within a build included a preliminary design walkthrough
(PDW), a
critical design walkthrough (CDW), and a turnover review (TOR).
The schedules for these milestones were flowed down from, and integrated with, the
higher level
project milestones – SRR, IPDR, PDR, and CDR.
The following figure provides an overview of a build’s life cycle and the focus of
activities:
Within a build, a well-defined sequence of design walkthroughs took place.
These were informal, detailed, technical peer reviews of intermediate design products.
They were attended by reviewers, including other designers, testers, and even
stakeholders like
customer, user, and project systems engineering personnel, with attendance kept to a
small group
of 10 to 20.
The explicit focus of these reviews was the important components, the architectural
interfaces,
and the driving issues – the 20% stuff that deserved scrutiny.
Coverage across all requirements and components was not required.
The design walkthroughs were informal and highly interactive with open critique.
Technical issues were noted as action items and tracked to closure.
In the PDWs and CDWs each of the participating CSCI managers presented appropriate
material.
Prototypes and
refinements
Informal
baseline
Enhancements Formal
baseline
Test and
maintenance
Component design and integration Component evolution and maintenance
􀁓 􀁓 􀁓 Structure Behavior
Completeness
and accuracy Maintenance
PDW CDW TOR
Integrated
Structural
Demonstration
Integrated
Performance
Demonstration
Baseline
Turnover
Assessment
FIGURE D-6. Basic activities sequence for an individual build
Preliminary Design Walkthroughs

Initial prototyping and design work was concluded with a PDW and a basic capability
demonstration.
The walkthrough focused on the structural attributes of the components within the build.
The basic agenda was tailored for each build.
For each CSCI it generally included the following topics:
􀀌 Overview: CSCI overview, interfaces, components, and metrics
􀀌 Components: walkthrough for each major component, showing its source code
interface,
allocated system requirement specification (SRS) requirements, current
metrics, operational concept for key usage scenarios, standalone test plan,
and error conditions and responses
􀀌 Demonstration: focused on exercising the control interfaces across the components
within
the integrated architecture
Critical Design Walkthroughs [CDW]
A build’s design work was concluded with a CDW and a capability demonstration that
exposed
the key performance parameters of components within the build.
The CDW focused on the completeness of the components and the behavioral perspective
of
operating within the allocated performance requirements.
The basic agenda was tailored for each build.
For each CSCI it generally included the following topics:
􀀌 CSCI Overview: interfaces, components, and metrics;
Summary of changes since PDW;
Disposition of all PDW action items;
Build integration test scenarios
􀀌 Components: walkthrough for each major component, showing its source code
interface,
allocated system requirement specification (SRS) requirements, current
metrics, operational concept for key usage scenarios, standalone test plan,
and error conditions and responses
􀀌 Demonstration: focused on exercising the critical component threads.
Code Walkthroughs
These were used to disseminate project-wide expertise and ensure the development of
selfdocumenting
source code.
The CSCI managers and software chief engineer coordinated the need for code
walkthroughs and
their allocation among various authors to meet the following objectives:
􀀻 Better dissemination of self-documenting source code style.
􀀻 Identification of coding issues not caught by compilers and source code analysis tools
o Readability issues: Object naming, coding style, and commenting style
o Complexity of objects or methods: levels of necessity
o Reuse: is custom code being developed where components are available
o Performance issues: implementation efficiency levels
􀀻 Reduction of the amount of source code needed for review in the larger design
walkthroughs
􀀻 Exposure of personnel to the products of experts
Code review, typically, involved a single reviewer going-in for detailed analysis using
on-line
source code browsing tools.
A one-page result of the review was given to the author, the CSCI manager, and the
software
chief engineer.
The software chief engineer was responsible for noting global trends, identifying
improvements
needed in code analysis tools, and raising lessons learned to the appropriate walkthrough
or other
technical exchange forum.
Turnover Reviews [TOR]

They were typically a one-month activity during which components were completed with
standalone
testing and turned over for configuration control, build integration testing, and
engineering
string testing.
The checkpoints used on CCPDS-R for the incremental design process are the minor
milestones.
The combination of walkthroughs and inspections are the 20% components with a
potentially
high return on human resource investment.
The real value of design walkthroughs and inspections was communications among
project
teams and methodical coordination of processes.
The technical interchange was mechanized by these checkpoints.
D.5.3 COMPONENT EVOLUTION
CCPDS-R used Ada as the life-cycle format for design evolution.
This allowed for software development progress metrics to be extracted directly from the
evolving source files.
The Ada design language had a special design package containing objects with names
prefixed
by the string TBD – for to be defined.
This package of TBD objects included predefined TBD types, TBD constants, TBD
values, and a
TBD procedure for depicting source lines of code associated with comments acting as
placeholders for as-yet undefined code segments.
The following procedure declaration:
TBD_Statements (Number_of_Statements: In Integer);
required that a parameter depict the number of statements estimated for a given code
segment
described with proper comments.
Source lines with calls to a TBD object were counted as ADL (Ada design language)
lines;
Source lines with no TBD references were counted as Ada source lines.
The following table provides an example of a component evolution:
TABLE D-2. A typical component evolution from creation through
turnover
VIEW PROGRAM UNIT TYPE Ada ADL TOTAL %
Creation
view
Total package
Inm_Erm_Procedures
Package
6
2
122
122
128
124
52
PDW
view
Total package
Inm_Erm_Procedures
All_Node_Connections
Create_Inm_Erm_Circuits
On_Node_Connections
Perform_Reconfiguration
Perform_Shutdown
Process_Error_Messages
Package
Procedure
Procedure
Procedure
Procedure
Procedure
Procedure
47
24
3
4
3
6
4
3
101
19
19
8
7
2
3
43
148
43
22
12
10
87
46
32
56
14
33
30
75
57
7
CDW
view
Total package
Inm_Erm_Procedures
On_Node_Connections
Perform_Shutdown
Package
Procedure
Procedure
Procedure
Procedure
Procedure
Procedure
87
30
16
8
9
6
6
12
48
11
0
4
0
2
1
30
135
41
16
12
987
42
65
73
100
67
100
75
86
29
Turnover
view
Total package
Inm_Erm_Procedures
On_Node_Connections
Perform_Shutdown
Package
Procedure
Procedure
Procedure
Procedure
Procedure
Procedure
137
42
16
12
9
8
7
43
0
0
0
0
0
0
0
0
137
42
16
12
987
43
100
100
100
100
100
100
100
100
The basic evolution would look like:

􀀻 At creation:
􀀈 Only the interface (the specification part) would be defined with Ada source lines and
corresponding comments.
􀀈 The estimated SLOC count for the component would be specified by a single
TBD_Statements line.
􀀻 At PDW:
􀀈 The substructure of the component would be readied along with most component
declarations and estimates of the subordinate program units using multiple calls to
TBD_Statements.
􀀈 At this time, there would be about 30% of the SLOC in Ada and 70% in ADL.
􀀻 At CDW:
􀀈 Most of the program unit interfaces and declarations would be fully readies in Ada,
with
some detailed processing still using TBD_Statements as placeholders.
􀀈 CDW-level components would be about 70% Ada and 30% ADL.
􀀈 A guideline also sated that by CDW, there wuld be no calls to TBD_Statements with
values greater than 25.
􀀻 By turnover:
􀀈 The string TBD would not appear anywhere in the source files.
􀀈 This corresponds to a complete implementation.
The evolution of most components followed this pattern, with occasional violation.
Detailed style standards also were there, as a basis of early code walkthroughs and the
requirements for an automated code auditor to check for numerous standards violations
before
turnover.
A by-product of using Ada as a design language for CCPDS-R:
The evolving source files were in a uniform representation format. The current work
accomplished – source line of Ada – and the current work pending – TBD_Statements –
could be
extracted easily.
The Ada source lines – though liable to further change in evolution – represented a
relatively
accurate assessment of work accomplished.
A metrics tool developed to scan Ada source files and compile statistics on the amount of
completed Ada and TBD_Statements.
The following table gives an example of the output of such a tool:
TABLE D-3. NAS CSCI metrics summary at month
10
ELEMENTS TOTAL DESIGNED CODED
Top-level components 40 39 33
Lower level components 13 13 10
Total program units 494 484 459
Source lines: 18,494 ADL:1, 858
10% TBD
Ada: 16,636
90% complete
This metric and the CCPDS-R coding standards provided metrics for monitoring the
progress
from several perspectives.
Some key measures of progress could be extracted directly from the evolving source
baselines.
The software engineers followed the software standards in coding the source files and
maintaining them in compilable formats.
Once a month, all source code was processed by the tools and integrated into various
perspectives for communicating progress.
The resulting metrics were useful to communicate about the need for resources, and need
for reprioritization
certain activities.
Acceptance by both manager and practitioner, and extraction directly from evolving
artifacts,
were crucial to the success of this metrics approach.
D.5.4 THE INCREMENTAL TEST PROCESS

The CCPDS-R build structure accommodated a manageable and straightforward test
program.
Because compilable Ada was used as the primary format in the life cycle, most
integration issues
– data type consistency, program unit obsolescence, and program unit dependencies –
were
caught and resolved in compilation.
Substantial informal testing took place as a natural by-product of the early architecture
demonstrations and the requirements that all components be maintained in a compatible
format.
This informal testing was not sufficient to verify that requirements were satisfied and
reliability
expectations were met.
A highly rigorous test sequence was devised with five different test activities:
① Stand-alone test
② Build integration test
③ Reliability test
④ Engineering string test
⑤ Final qualification test
① Stand-alone Test (SAT).
􀀈 The development teams were responsible for SAT of components before delivery into
a formal, configuration controlled test baseline used for all other test activities.
􀀈 SAT tested a single component – at times, comprising of lower level components – in
a stand-along environment.
􀀈 This level of testing corresponds to completeness and boundary condition tests to the
extent possible in a stand-alone context.
② Build Integration Test (BIT).
􀀈 A smoke test to ensure that previously demonstrated capabilities still operated as
expected.
􀀈 A BIT sequence is the primary quality assessment vehicle for closing out a turnover
review.
􀀈 A build turnover may take days or weeks, depending on its size or percentage of
componentry.
􀀈 The purpose of BIT is to establish a stable, and reliable baseline, and not to verify
requirements.
􀀈 It is very informal, dynamic, and focused on exposing errors and inconsistencies.
􀀈 Build integration tests validate the following:
♦ Previously demonstrated threads can be repeated successfully
♦ Previously defined deficiencies have been resolved
♦ Interfaces across components are tested completely
♦ The baseline is stable enough for efficient requirements verification testing
③ Reliability Test.
􀀈 An output of the BIT process and turnover review was a stable test baseline that was
subjected to extensive stress testing for long periods of time under randomized,
realistic test scenarios.
􀀈 This sort of testing was designed to help uncover potentially insipid, transient errors
of major design consequences.
􀀈 Reliability testing logged as much test time as the resources were idle.
④ Engineering String Test (EST).
􀀈 EST focused on verifying specific subsets of requirements across multiple CSCIs
through demonstration and test of use case realizations – called capability threads.
⑤ Final Qualification Test (FQT).
􀀈 FQT were equivalent to EST, except that they represented the set of requirements that
could not be verified unless the whole system was present.
􀀈 For example, a 50% reserve capacity requirement could not be verified until the
whole system was operational.
The overall subsystem build plan was driven by allocating all reliability-critical
components –
causing type 0 errors – to build 0, 1, or 2.
The following figure illustrates the overall flow of test activities and test baselines
supporting
this build plan.
The sequence of baselines allowed maximum time for the early-build, critical-thread
components
to mature.
To increase trustworthiness in their readiness for operational use further extensive testing
was
done on the components.
Testing process went on till such a time that an empirical [software] mean time between
failures
(MTBF) was demonstrable and acceptable to the customer.
The CCPDS-R build sequence and test program are good examples of confronting the
most
important risks first.
A stable architecture was also achieved early in the life cycle so that substantial reliability
testing
could be performed.
This strategy allowed useful maturity metrics to be established to demonstrate a realistic
software MTBF to the customer.
D.5.5 DOD-STD-2167A ARTIFACT
CCPDS-R software development was required to comply with DOD-STD-2167A
documentation
standard.
Data item descriptions in 2167A specified document format and content.
Substantial tailoring was allowed to match the development approach and to
accommodate the
use of Ada as a design language and also as the implementation language.
Dev/SAT: Development and Stand-Alone Test
Component-level testing
BIT: Build Integration Test
Informal smoke testing in the integrated
architecture
EST: Engineering String Test
Formal scenario test demonstrating
requirements compliance
Build 0
Dev/SAT
Build 0
Baseline
Build 1
Dev/SAT
Build 1
Baseline
Build 0
BIT
Build 2
Dev/SAT
Build 2
Baseline
Build 1
BIT
Build 3
Dev/SAT
Build 3
Baseline
Build 2
BIT
Build 4
Dev/SAT
Build 4
Baseline
Build 2
EST
Build 3
BIT
Build 5
Dev/SAT
Build 5
Baseline
Build 3
EST
Build 4
BIT
Build 4
EST
Each subsequent build baseline
provides a controlled
configuration for:
􀂾 Maintenance of stand-alone
tested components
􀂾 Testing of additional capabilities
􀂾 Regression testing of previous
capabilities
􀂾 After-hours reliability stress
testing
FIGURE D-7. Incremental baseline evolution and test activity flow
Primary tailoring included the following:

1. Use the evolving Ada source files as the single homogeneous life-cycle design format
and
evolution of these files in a self-documenting manner.
This technique exploited the readability features of Ada and avoided the extra effort in
preparing separate, detailed design descriptions that may diverge from the
implementation.
2. Organization of test sequences and deliverable documents around the build content
driven
by subsets of use case – referred to as engineering strings and scenarios, than CSCI.
This string-based testing spanned components in multiple CSCIs.
It was organized by build and mechanized via a software test plan, software test
procedure,
and software test report documentation sequence.
These document sequences were provided for each BIT (one for each build), each EST
(for
builds 2, 3, and 4), and FQT (one final all-encompassing test sequence).
Each test sequence involved components from several CSCIs because integration was
proceeding continuously.
3. Building of separate unit test documentation as self-documented, repeatable software.
This was treated like other operational code so that it was maintained homogeneously and
up-to-date for automated regression testing.
The same concept was used for the BIT and EST scenario testing:
Instead of developing test procedures documents, the CCPDS-R process generated
selfdocumenting
test scenarios that were programs in their own way.
As they were subjected to change management like other software, they were always
maintained up-to-date for automated regression testing.
The following table summarizes the software documentation that resulted from 2167A
tailoring
and the corresponding recommended artifacts:
TABLE D-4. CCPDS-R software artifacts
NO.
CONTRACT-DELIVERABLE
DOCUMENT
ARTIFACT COUNTERPART
1 System specification Vision statement
6 Software requirements specification
(SRS)
End-item release specifications
1 for each CSCI
1 System design document (SDD) Architecture description
6 Software top-level design document
(STLDD)
UML design models
1 for each CSCI
42 Software development file (SDF) Implementation set artifacts
1 per component
6 Software product specifications (SPS) Final implementation set artifacts
Deployment set artifacts
1 for each CSCI
4 Demonstration plan Major milestone release specifications
1 for each major demonstration
4 Demonstration report Major milestone release description
1 for each major demonstration
9 Test data file (TDF) Release descriptions
1 for each build’s BIT, EST, and FQT test
sequences
4 Software test plan (STP) Release specifications
Design set artifacts, test models
4 Software test procedure (STPR) Implementation set artifacts
4 Software test report (STR) Release descriptions
1 Software development plan (SDP) Software development plan
1 Software standards and procedures
manual (SSPM)
Software development plan
48 Project management review (PMR) Status assessments
3 Software user manual (SUM) User manual
1 for each operational role
The 2167A approach was inefficient, even with tailoring.
It was clear form the outset that the documentation burden was tremendous, but straying
away
from convention was too risky.
The above table focuses only on software documentation, excluding documents that
supported
the systems engineering concerns – safety, human factors engineering, reliability, and the
operational community – cutover plan, logistical support, and training.
Those documents also required input and support from the software organization, even
though
the primary responsibility for them resided elsewhere within the CCPDS-R project.
One of the key artifacts in the above table is the software development file (SDF).
For CCPDS-R, this was an organized directory of on-line information, maintained as
compilable,
self-documenting Ada source code.
The SDF had several sections of content that evolved as described in the following table:
TABLE D-5. Software development file evolution
SECTION PDW STATUS CDW STATUS TOR STATUS
Requirements Summarized Allocated Traced
Component overview Complete Complete Complete
Top-level program unit Ada Ada Ada baseline
Subordinate units Ada/ADL Ada/ADL Ada baselines
SAT plan Draft Complete Complete
SAT test code Some demonstration Some demonstration Ada baselines
SAT test results Some demonstration Some demonstration Ada baselines
SCO log None None Initial
Metrics Initial metrics Updated metrics Updated metrics
Code auditor results None Initial Complete
Notes/waivers None None As needed
The approach evolved in CCPDS-R is: Initially, most artifacts were paper based.
After the customer showed interest in the demonstration artifacts and the configuration
baselines
of the product components and test components, the demand for paper documents
subsided.
A transitional aspect is that the SDF was completely electronic, in which the design and
coding
standards promoted self-documenting artifacts.
Separate artifacts to document the design and code were no longer necessary.
One issue was the need for a higher level, graphical design description.
This was provided in the system design document and in software top-level design
documents
using ad hoc text and graphics to represent the design.
These representations were ambiguous, frequently out of date, and difficult to understand.
The use of UML notation, an architecture approach, visual modeling tools, and support
for
round-trip engineering would have improved the design representation approach and
would have
eliminated a lot of wastage of effort.
D.6 DEMONSTRATION-BASED ASSESSMENT
Conventional design reviews define standards that result in broad reviews.
Only a small portion of these is important or understood by a diverse audience.
For example, reviewing all requirements in equal detail is inefficient and unproductive.
Only some requirements are critical to design evolution of the architecture, and others are
critical
only to a few components.
The CCPDS-R software review process improved the efficiency of design evolution,
review, and
stakeholder concurrence in two ways:
☺ By allocating the technical breadth and depth of review to smaller scale design
walkthroughs, and
☺ By focusing the major milestone reviews on the important design trade-offs.
Focusing the design review on an executable demonstration provided a more
understandable and
concrete review vehicle to the stakeholders.
Conventional projects built demonstrations or benchmarks of stand-alone design issues –
like a
user-system interface mockup or a critical algorithm.
The design baseline was usually represented on paper in design review presentations and
design
documents.
It was easy for stakeholders to accept these artifacts as valid, but they were ambiguous
and not
amenable to straightforward change management.
The CCPDS-R software design review process was demonstration-based, requiring
tangible
evidence that the architecture and design progress were leading to an acceptable quality
product.
The design review demonstrations provided such evidence by demonstrating an
executable
version of the current architecture under the critical usage scenarios.
A number of qualities of the evolving architecture baseline were made visible at any
design
review.
These demonstrations provide acute insight into the integrity of the architecture and its
subordinate components, the run-time performance risks, and the understanding of the
system’s
operational concept and key use cases.
Lessons from the design walkthroughs and their demonstrations were tracked via action
items.
Major milestone design reviews provided both a briefing and a demonstration.
The briefing summarized the overall design and the important results of the design
walkthroughs,
and presented an overview of the demonstration goals, scenarios, and expectations.
The demonstration at the design review was a culmination of the real design review
process.
The sequence of demonstration activities included
♦ the development of a plan
♦ definition of a set of evaluation criteria
♦ integration of components into an executable capability
♦ generation of test drivers, scenarios, and throw-away components
The demonstration plans were not elaborate, yet, for each demonstration, they captured
􀀌 the purpose of the demonstration
􀀌 the evaluation criteria for assessing the results
􀀌 the scenarios of execution
􀀌 the overall hardware and software configuration
A modern demonstration-based approach frequently starts with a pessimistic assessment
and
then gets better.
The following key lessons were learned in the CCPDS-R demonstration activities:
􀀻 Early construction of test scenarios has a high ROI.
♦ The early investment in building some of the critical test scenarios served two
invaluable
purposes:
􀂾 It force-implemented an important subset of the requirements into a tangible form.
These test scenarios caused several interactions with the users that increased the
understanding of requirements early in the life cycle.
􀂾 These implementation activities got the test team involved early in building an
environment for demonstration and testing that was highly mature by the time the
project reached full-scale testing.
􀀻 Demonstration planning and execution expose the important risks.
♦ Negotiating the content of each demonstration and the associated evaluation criteria
served to focus the architecture team, management team, and other stakeholders on the
critical priorities of the early requirements and architecture activities.
♦ Instead of dealing with the full elaboration and traceability of all 2,000 requirements,
the
team focused on understanding the 20 or so designs drivers.
􀀻 Demonstration infrastructure, instrumentation, and scaffolding have a high ROI.
♦ Initially, there was a concern that these demonstrations would require a significant
investment in throw-away components which were only needed for demonstration.
♦ In most cases, very little of this work ended up being thrown away.
♦ Most components were reused in stand-alone tests, build integration tests, or
engineering
string tests.
♦ As a benchmark of the level of throw-away components, IPDR demonstration
amounted
to 72,000 SLOC. Of this, only about 2,00 SLOC – smart stubs and dummy messages –
were thrown away.
􀀻 Demonstration activities expose the crucial design trade-offs.
♦ The integration of the demonstration provided timely feedback on the important design
attributes and the level of design maturity.
♦ The demonstration efforts required 10 to 12 designers integrating components into the
architecture.
♦ They ran into a number of obstacles, built many workarounds, and performed several
components redesigns and a few architecture redesigns.
♦ Most of this work took place over a month, that too late at night.
♦ This late night work was very detailed integration-debug-rebuild-redesign and it acted
as
a very effective design review.
♦ They gave a first-hand understanding of the architectural strengths and weaknesses,
mature components, fragile components, and the priorities in post-demonstration
improvement
􀀻 Early performance issues drive early architecture improvements.

♦ The first two demonstrations contained extensive functionality and demonstrated
runtime
performance that was significantly less than required.
♦ The demonstration evaluation criteria were close to the end-item performance
requirements.
♦ This was counterproductive as it led to an early expectation on the part of contract
monitors that demonstration evaluation criteria and requirements would be closely
aligned.
♦ Though the customer and the TRW management were initially anxious about this
situation, the straightforward resolutions and substantial progress made in subsequent
demonstrations pacified these concerns.
The implementation of demonstrations as the predominant intermediate product of an
organic
development effort is well understood.
The IPDR Demonstration [IPDR – Interim Preliminary Design Review]
The three critical objectives of the IPDR major milestone demonstration of the Common
Subsystem:
1. Tangible assessment of the software architecture design integrity through construction
of
a prototype SAS.
2. Tangible assessment of the critical requirements understanding through construction of
the worst-case missile warning scenario
3. Exposure of the architectural risks associated with peak missile warning scenario and
the
fault detection and recovery scenario.
The CCPDS-R software culture is evident in these objectives.
These demonstrations were engineering activities with ambitious goals, open discussion
of tradeoffs,
and a show-me approach to substantiating assertions about progress and quality.
The results of a demonstration were apt to change requirements, plans, and designs
equally; all
three of these dimensions evolved during the life cycle. Demonstration activities spanned
a six-month period, with the first three months focused on
planning.
A few people from the stakeholder teams participated in specifying the formal evaluation
criteria.
The following figure summarizes the schedule for the IPDR demonstration:
The above figure includes details of the intense integration period in the two months
before the
demonstration.
Months After Contract Award
5 6 7 8 9 10 11 12
Weeks After Activity Initiation
123456789
Demonstration Milestone
Preliminary demonstration plan
Government feedback plan
Final demonstration plan
Demonstration preparation
Re-demonstration and report
NAS, demo testbed installation
Scenario/message definition
SAS construction
Demo driver, stub construction
Demonstration integration
Dry run, demonstration tuning
Demonstration
FIGURE D-8. CCPDS-R first demonstration activities and schedule
The first three months of planning – encompassing a draft plan, government review and
comment, and final plan production – could be achieved with a collaborative team of all
interested stakeholders.
The review sequence was a contractual requirement.
This demonstration was the first attempt at constructing a full-scale SAS.
So, this was the first major integration effort for the Common Subsystem.
The subsequent demonstrations were shorter, but equally intense integration activities.
IPDR Demonstration Scope
The basic scope of the IPDR demonstration was defined in the CCPDS-R statement of
work:
The contractor shall demonstrate the following capabilities at the NORAD Demo 1:
system initialization, system failover and recovery, system reconfiguration, and data
logging.
The customer and TRW understood these capabilities.
The capabilities represented the key components and use cases necessary to meet the
objectives.
1. System services – interprocess communication services, generic applications control
(generic task and process executives), NAS utilities (list routines, name services, string
services), and common error reporting and monitoring services – were the general utility
software components of NAS.
These services were to be reused across al three subsystems.
They were the foundation of the architectural infrastructure.
They were the building blocks needed to demonstrate an executable thread.
2. Data logging (SSV CSCI) was a capability to instrument some of the results of the
demonstration and was a performance concern.
3. Test message injection (TAS CSCI) components permitted messages to be injected
into
an object in the system to provide a general test driver capability.
4. System initialization was the fundamental use case (called phase 1 in Figure D-8) that
would illustrate the existence of a consistent software architecture skeleton and error-free
operation of a substantial set of the system services.
A performance risk was the requirement of initializing a large distributed software
architecture – both custom and commercial components – within a given time.
5. The second scenario (phase 2) was to inject the peak message traffic load into the
architecture and cause all the internal message traffic to cascade through the system in a
realistic way.
Executing this scenario required all the software objects to have simple and smart
message processing stubs to be “modeled”.
These simple Ada programs completed the thread with dummy message traffic by
reading and writing messages as expected under peak load.
Prototype message processing software was constructed to accept incoming messages and
forward them through the strings of components of the SAS.
This included all significant expected traffic, from receipt of external sensor messages to
missile warning display updates.
It also included all overhead traffic associated with status monitoring, error reporting,
performance monitoring, and data logging.
6. System failover and recovery (phase 3) was a risky scenario as it required a very
sophisticated set of state management and state transition control interfaces to be
executed across a logical network of hundreds of software objects.
The basic operation of this use case was to inject a simulated fault into a primary thread
operational object to exercise the following sequence of events:
♦ Fault detection
♦ Fault notification
♦ Orchestrated state transition from primary thread to backup thread
♦ Shutdown of primary thread
All these network state transitions needed to occur without interruption of service to the
missile warning operators.
Reconfiguration meant recovering from a degraded mode.
Following the system failover defined above, a new backup thread would be initialized so
that there was minimum exposure to single-point failures. Repair immediately followed
failover, in the delivered system.
IPDR Demonstration Evaluation Criteria

The essential IPDR evaluation criteria were derived from the requirements, the risk
assessments, and the evolving design trade-offs:
􀀻 All phases:
􀂃 No critical errors shall occur.
􀀻 Phase 1:
􀂃 The system shall initialize itself in less than 10 minutes.
􀂃 The system shall be initialized from a single terminal.
􀂃 After initialization is complete, the number of processes, tasks, and sockets shall
match exactly the expected numbers in the then-current SAS baseline.
􀀻 Phase 2:
􀂃 The total processor utilization for each node shall be less than 30% when
averaged over the worst-case peak scenario.
􀂃 There shall be no error reports of duplicate or lost messages.
􀂃 All displayed data shall be received within 1 second from its injection time.
􀂃 The message injection process shall maintain an injection rate matching the
intended scenario rate.
􀂃 The data logs shall show no unexpected state transitions or error reports and
shall log all injected messages.
􀀻 Phase 3:
􀂃 The operator shall be capable of injecting a fault into any object.
􀂃 An error report shall be received within 2 seconds of the injection of a fault.
􀂃 The switchover from the primary to backup thread shall be completed within 2
seconds of the fault injection with no loss of data.
􀂃 The shutdown of the failed primary thread and re-initialization as a new backup
thread shall be completed in less than 5 minutes from failure.
􀂃 The data logs shall match the expected state transitions with no fatal errors
reported other than the injected fault.
There were more evaluation criteria for less important visibility into detailed capabilities
and
intermediate results.
IPDR Demonstration Results
The results of the IPDR demonstration were fruitful.
Out of the 37 evaluation criteria, 31 were considered satisfactory.
Six criteria – including three of the above essential ones – were not met.
Excessive processor utilization during the peak load scenario was of major concern.
The threshold was 30%, and the actual utilization was 54%.
This corresponded to the essential overhead of the architectural infrastructure, operating
system,
and networking software.
Because this was a risk of the CCPDS-R reusable middleware design, it received
extensive
attention.
Five distinct action items for performance analysis were created and an action item to
demonstrate the performance improvement at the next project management review afer
the five
action items were resolved.
The five action items were as follows:
1. Update the scenario
♦ The actual test scenario used as the peak load was in fact about 33% worse than the
real peak load.
♦ The internal message traffic threads were worse than the true worst case.
♦ The IPDR demonstration forced TRW, the customer, and the user to converge on a
better understanding of the real worst-case mission scenario in tangible and objective
terms.
♦ It also forced the architecture team to understand better the message traffic patterns and
the optimization tradeoffs.
♦ The return on investment realized from this activity was never quantified, but it was
enormous.
2. Tune the interprocess communications (IPC) buffering parameters.

♦ The NAS components had many options for optimizing performance.
♦ Even though numerous local optimizations were made over the final month of
integration activities, there was need for a more global analysis to take advantage of
lessons learned in exploiting the patterns of message traffic.
3. Enhance network transactions.
♦ The node-to-node message traffic was a bottleneck because the current version of
operating system (DEC VMS 4.7) did not exploit the symmetric multiprocessing
capability of the VAX processors.
♦ The pending upgrade to VMS 5.0 would provide an increase to this component of the
overall performance.
4. Improve performance of the IPC component.
♦ A bottleneck in the NAS interprocess communications component had an impact on
one of the performance optimization feature.
♦ This was identified as a design flaw that needed resolution.
5. Improve reliability in the IPC component.
♦ The IPDR demonstration exposed another serious design flaw: Erroneous behavior
could occur under a very intense burst of messages.
♦ The overly stressful scenario made this flaw obvious.
♦ In a system with the stringent reliability requirements of CCPDS-R, it had to be fixed,
even though it may never occur in operations.
♦ It could have caused malignant breakage and immense scrap and rework if the flaw had
gone undetected until late in the project.
The five action items accurately represented the critical issues still unresolved at the time
of the
demonstration.
The TRW management and the customer were anxious, as they expected the
demonstration to go
conclude with no open issues.
Yet, both parties were pleased with the demonstration process and the unprecedented
insight they
had achieved into the true design progress, design trade-offs, requirements understanding,
and
risk assessment.
The closure of the action items and the re-demonstration relieved the anxiety of the
stakeholders.
The team demonstrated the flexibility of the architecture and the opportunities for
optimization,
and succeeded in reducing the overall utilization from 54 to 35%.
These were the visible and formal results of the IPDR demonstration.
Other intangible results were also observed.
Over a period of time of late-night integration and debug sessions – during which
priorities were
coordinated, design issues were resolved, workarounds were brainstormed, stakeholders
were
placated with on-going status reports, and the engineering teams were motivated toward
an
ambitious objective – the following lessons were forward:
a) Very effective design review was occurring throughout the period.
􀀈 The engineering team’s review was presented to the stakeholders in the
demonstration.
􀀈 Beyond the 5 open issues, 50 or more design issues had been opened, resolved, and
closed during the integration activity.
􀀈 This early resolution of defects – in the requirements specification, the process, the
tools, and the design – had undocumented but extensive return on investment by
avoiding a tremendous amount of late downstream breakage.
b) Detailed insight was gained into the weaknesses of the design and its robustness, and
why,
from this activity.
􀀈 When issues were uncovered in some components, the responsible designers
delivered a resolution in a time-bound manner.
􀀈 At the conclusion of the demonstration activity, it became apparent about where
change was easy and where it was difficult.
􀀈 This helped in structuring the risk profile for subsequent planning, personnel
allocation, and test priorities.
c) The demonstration served as a strong team-building exercise with a tangible goal and
the
engineers were working in the forum of getting the stuff to work.
d) The detailed technical understanding and objective discussions of the design trade-offs
developed a trustworthy relationship with all stakeholders – armed with facts and figures,
not subjective speculation.
Government Response to the IPDR Demonstration

The following is a summary of the concerns to show up when an organization adopts a
paradigm
shift from the conventional design review to the demonstration-based process:
The following observations summarize the submittal of the Demo 1 Plan and the
modifications
made to the Preliminary Demo 1 Plan based on the Government’s comments:
1. The revision has eliminated all requirements references to avoid making any allusion
to
intent of satisfying, proving or demonstrating any requirements.
The test organization performed the requirements verification rigorously with
traceability. The demonstration is intended to be
♦ An engineering-intensive activity
♦ Streamlined with minimal documentation
♦ An opportunity to provide insight into the design feasibility and progress
The intention of TRW was to maximize the usefulness of the demonstration and to avoid
documentation-intensive effort.
2. Providing more information in a single document makes the reviewer’s job easier but
it
would also be excessive, more time-consuming, and counterproductive to produce,
thereby reducing the technical content of the engineering product under review.
Hence, more details on requirements, designs, etc., was not included in the Demo Plan
3. The evaluation criteria in the demonstration plan needed careful scrutiny because of
the
concern over the relationship of the demonstration to the requirements.
The evaluation criteria should be explicit, observable, and insightful with respect to
determining design feasibility, especially at such an early point in the life cycle.
The requirements perspective and the demonstration perspective are different and
difficult to relate.
4. The source code for the components being demonstrated was not delivered with the
plan
as required in the statement of work.
Instead of delivering all the source code, specific components were provided to interested
reviewers.
The five critical action items, initially, caused intense concern.
After TRW demonstrated resolution of these action items in a month’s time, the
government’s
response was positive.
The objective insight, open discussion of trade-offs, and understandability of the design
issues,
requirements issues, and performance issues resulted in exceptional relationships among
stakeholders.
D.7 CORE METRICS
The CCPDS-R metrics approach was first developed solely to manage the project and
meet the
needs of the contract.
CCPDS-R was not near perfect; a number of mistakes were made.
This was true of the metrics program also.
It measured some of the wrong things, measured some things wrong, struggled with early
interpretations, and used some manual methods where automation was needed.
At the same time, these metrics activities led to more teamwork, better processes, better
understanding of risks, and better product produced efficiently.
Following several improvements in interpretation, automation, presentation, and
definition, there
was nearly universal support.
The objective data from the metrics program was used by all to substantiate the plans,
risks,
design directions, and results.
In the CCPDS-R, the metrics program was a contractual requirement, but the government
did not
define the actual metrics to be used.
Hence, the contract team had to select the metrics program and take the ownership.
TRW formulated a metrics program with the following four objectives:
1. Provide data for assessing current project trends and identifying the need for
management
attention.
2. Provide data for planning future builds and subsystems
3. Provide data for assessing the relative complexity of meeting the software end-item
quality requirements
4. Provide data for identifying where process improvements are needed substantiating the
need
There are several instances of progress metrics and quality indicators of scrap, rework,
and
maturity.
The basis for automation required some interesting technical approaches embedded
directly in
the evolving design and code artifacts.
D.7.1 DEVELOPMENT PROGRESS
Measuring development progress accurately with several concurrent builds in various
states was
a complex undertaking for the Common Subsystem management team.
A consistent approach providing accurate insight into subsystem-level status and build
status was
devised.
The goal was a balanced assessment that included the following:
􀂾 The Ada/ADL metrics:
􀀌 To provide good insight into the direct indicators of technical progress
􀀌 These were accurate at depicting the true progress in design and implementation
􀀌 These were weak at depicting the completed contract deliverables and financial status
􀂾 Earned value metrics:
􀀌 To provide good insight into the financial status and contract deliverables
􀀌 These were weak indicators of true technical progress
Like other software metrics, these two perspectives were initially inaccurate assessments
of
absolute progress.
They were excellent assessments of relative progress when tracked periodically.
With more experience, the absolute assessments also became well-tuned predictors of
success or
risk.
The following chart illustrates the overall assessment:
The above figure depicts the top-level progress summary for each build and for the
Common
Subsystem as a whole.
The length of the shading within each build relative to the dashed line – current month –
identifies whether progress was ahead of or behind schedule.
Build 0
Build 1
􀁓PDW 􀁓CDW 􀁓􀁓T0R
Development Stand-alone test
􀁓
Turnover for
configuration control
Build 2
􀁓PDW 􀁓CDW 􀁓TOR
Build 3
􀁓PDW 􀁓CDW 􀁓TOR1 􀁓TOR2
Build 4
􀁓PDW 􀁓CDW 􀁓TOR
Build 5
||||||||
0 5 10 15 20 25 30 34
􀁓SRR 􀁓IPDR 􀁓PDR 􀁓CDR
PDW: Preliminary Design Walkthrough
CDW: Critical Design Walkthrough
TOR : Turnover Review
􀁓Original milestone
KSLOC
8
43
61
173
83
7
355
Months after contract award
Common Subsystem Design
Common Subsystem SAT
Time = Month 17
FIGURE D-9. Development progress summary
The shading was a judgment by the software chief engineer, who combined the monthly
progress
metrics and the monthly financial metrics into a consolidated assessment.
Monthly collection of metrics provided detailed management insight into build progress,
code
growth, and other indicators.
To provide multiple perspectives, the metrics were collected by build and by CSCI.
Individual CSCI managers collected and assessed their metrics before the metrics were
incorporated into a project-level summary.
This process was objective, efficient, and meaningful.
The lowest level estimated of TBD_Statements were subjective. They were determined
by the
most knowledgeable people – the designers,.
They were being maintained in the evolving source code format as it was the format used
by the
designers. This increased the likelihood that the artifact would be kept up-to-date.
This process also assured consistent and uniform communication of progress across the
project.
The following figure illustrates the monthly progress assessments for the Common
Subsystem
and each build:
||||||||||
3 6 9 12 15 18 21 24 27 30
Subsystem progress (% coded)
||||||||||
100%
Build 0
􀁓
Build 1
􀁓
Build 2
􀁓
Build 3
􀁓
Build 4
􀁓
Build 5
􀁓
Individual
build progress
Contract Month
||||||||||
3 6 9 12 15 18 21 24 27 30
||||||||||
100%
Actuals
Plan
IPDR
􀁓
PDR
􀁓
CDR
􀁓
Contract Month
Common Subsystem Progress
FIGURE D-10. Common Subsystem development progress
In the above figure, the planned evolution was based on weight-averaging the SLOC
counts for
each build with the guidelines of: 30% done by PDW and 70% done by CDW.
Overall, the Common Subsystem performed very close to its plan, with one exception:
The progress achieved at IPDR reflected the unexpected positive impact of the source
code
generation tools, particularly for the SAS generation of 50,000+ SLOC.
Performance against plans varied for the individual builds. Each build tracked its plan
fairly well.
The progress of the subsystem and each build was assessed monthly with internal
management
and the customer in the project management reviews.
The objectivity approach was a key contributor to the non-adversarial relationship that
evolved
among all the stakeholders.
D.7.2 TEST PROGRESS
The test organization was responsible for build integration tests and requirements
verification
testing – SATs, ESTs, and FQT.
Build integration testing (BIT) was less effective in uncovering problems.
BITs were to be a complete set of integration test procedures from the most basic
capability to
off-nominal boundary conditions.
Most of this work was redundant with demonstration integration efforts.
So, the BITs were frequently redundant with demonstration preparation and were less
costeffective
than if the demonstration preparation activities were combined with BIT and made a
responsibility of the test organization.
The following table summarized the build 2 BIT results:
TABLE D-6. SCO characteristics for build 2 BIT testing
PROBLEM SOURCE MINOR
(<1 HOUR)
MODERATE
( < 1 DAY)
MAJOR
(>1 DAY)
TOTAL
Requirement interpretation 5 5
Inadequate stand-along test 3 4 2 9
Interface problem 9 2 1 12
Inadequate performance 1 1
Desired enhancement (not a problem) 3 3
Inconsistent configuration 3 2 5
Total 24 8 3 35
The entries in the above table reflect a highly integrated product state.
More effort was allocated to BIT planning, preparation, and conduct.
The merging of the demonstration preparation and BIT activities would have enabled
more
integration before turnover and more efficient regression testing after turnover to ensure
that all
previous issues were resolved.
The following table and figure provide perspectives on the progress metrics used to plan
and
track the CCPDS-R test program:
TABLE D-7. Requirements verification work by test type and CSCI
Test type NAS SSV DCO TAS CMP CCO QPR TOTAL
Build 0/1 SAT 42 5 47
Build 2 SAT 11 52 63 15 12 153
Build 3/4/5 SAT 65 62 18 198 46 389
EST 1/2 131 39 77 94 341
EST 3 32 49 117 42 240
EST 4 16 172 219 5 4 6 422
EST 5/FQT 5 105 84 42 54 207 46 543
Totals 237 482 622 221 268 259 46 2,135
The figure plots the progress against the plan for requirements verification tests.
SATs, ESTs, and FQTs were sources of test cases used.
SATs were the responsibility of the development teams, executed in the formal
configuration
management environment and peer-reviewed by the test personnel.
ESTs consisted of functionally related groups of scenarios that demonstrated
requirements
spanning multiple components.
FQTs were tests for requirements compliance that were not demonstrated until a
complete
system existed.
Quantitative performance requirements (QPRs) spanned all CSCIs.
Formal SAT testing was more difficult than planned.

This was primarily due to excessive design detail in the software requirements
specifications and
in the project review and signoff procedures.
Formal SAT testing was scrutinized by the government and required long lead times for
review.
The formal SAT process was one of the main reasons for the turnover reviews to be
consistently
completed within the plan.
D.7.3 STABILITY
The following figure illustrates the overall rate of configuration baseline changes:
The above figure shows the cumulative number of SLOC broken – checked out of the
baseline
for rework because of an identified defect, enhancement, or other change, and the number
of
SLOC repaired – checked back into the baseline.
Breakage rates that diverged from repair rates resulted in reprioritization of resources,
and
corrective actions taken to ensure that the test organization – driving the breakage and
development organization – driving the repair, remained in relative equilibrium.
|||||||||
||||||||||
32 34 36 38 40 42 44 46 48
Actuals
Plan
100%
Test progress at month 41, for example
523 of 589 SAT verifications
1,003 of 1,003 EST verifications
0 of 543 EST 5/FQT verifications
1,526 of 2,135 requirements (72%) verified
||||||||||
5 10 15 20 25 30 35 40 45
Cumulative SLOC
10,000 
80,000 
60,000 
40,000 
20,000 
Contract Month
Repaired
Broken
FIGURE D-11. Common Subsystem test progress
FIGURE D-12. Common Subsystem Stability
D.7.4 MODULARITY
The following figure identifies the total breakage as a ratio of the entire software
subsystem:
This metric identifies the total scrap generated by the Common Subsystem software
development
process as about 25% of the whole product. Industry average software scrap runs in the
40% to
60% range. The initial configuration management baseline was established around the
time of
PDR, (month 14). Later, 1,600 discrete changes were processed against configuration
baseline.
D.7.5 ADAPTABILITY
Overall, about 5% of effort was expended in rework activities against software baselines.
The average cost of change was about 24 hours per SCO. These values prove the ease
with
which the software baselines could be changed. The level of adaptability achieved by
CCPDS-R
was four times better than the typical project.
||||||||||
5 10 15 20 25 30 35 40 45
25% 

20% 

15% 

10%

5%

Cumulative SLOC
Contract Month
Closed rework Currently open rework
About 25% of all
SLOC were scrapped
and reworked after
their initial baseline
50 
40 
30 
20 
10 
|||||||||||
14 24 48
Maintenance changes
Implementation
Changes
Design
Changes
Design changes: Architecture changes that
typically span multiple components and teams
Implementation changes: Pre-FQT
changes, typically isolated to a
single component and team
Maintenance changes: out-ofscope
changes performed under
separate contract
Average hours/SCO
Common Subsystem Schedule (months)
PDR
􀁓
CDR
􀁓
FQT
􀁓
FIGURE D-13. Common Subsystem modularity
FIGURE D-14. Common Subsystem adaptability
The above figure plots the average cost of change across the Common Subsystem
schedule.
The 1,600+ SCOs processed against the evolving configuration baseline by FQT resulted
a stable
cost of change.
CCPDS-R proved to be a counter-example to the maxim “the later you are in the life
cycle, the
more expensive things are to fix”
Most of the early SCO trends were changes that affected multiple people and multiple
components – design changes in the above figure.
The later SCO trends were usually localized to a single person and a single component –
implementation changes in the above figure.
The final phase of SCOs reflected an uncharacteristic increase in breakage, the result of a
large
engineering change proposal that completely changed the input message set to the
Common
Subsystem.
This area turned out to be more difficult than thought of.
Although the design was robust and adaptable for a number of premeditated change
scenarios, an
overhaul of the message set was never foreseen nor accommodated in the design.
D.7.6 MATURITY
CCPDS-R had a specific reliability requirement with a specific allocation in the software.
The independent test team constructed an automated test suite to exercise the evolving
software
baseline with randomized message scenarios.
Extensive testing was done under realistic conditions to substantiate software MTBF in a
credible way.
The reliability-critical components were subjected to the most reliability stress testing.
This plan ensured early insight into maturity and software reliability issues.
The following figure illustrates the results:
With modern distributes architectures, statistical testing serves two purposes: (1) it
ensures
maximum coverage, and (2) uncovers significant issues of races, deadlocks, resource
overruns,
memory leakage, and other Heisen-bugs (uncertainty conditions).
Overall system integrity can be tested by executing randomized and accelerate scenarios
for long
periods of time.
|||
10,000 50,000 1,00,000
30,000 
(1,08,528)/4 = 27,132 hours
Build 0, 1, 2 mean time between
critical failures (reliabilitycritical
components)
Test
Suite
Software
Builds
Test
Hours
Critical
Failures
Cumulative
Failures
4 0, 1, 2, 3, 4, 5 19,400 2 17
3 0, 1, 2, 3, 4 23,068 2 17
2 0, 1, 2, 3, 4 20,600 2 18
1 0, 1, 2 1,08,528 4 26
MTBF (hours)
FIGURE D-15. Common Subsystem maturity
D.7.7 COST/EFFORT EXPENDIURES BY ACTIVITY
The following table provides the overall cost breakdown for the CCPDS-R Common
Subsystem:
TABLE D-8. Common Subsystem cost expenditures by top-level WBS element
WBS
ELEMENT
COST
(%)
ACTIVITIES AND ARTIFACTS
Management and
administration
9 Deliverable plans, administrative support, financial administration,
customer interface contracts, overall control and leadership
Process/product
specification
7 Technical requirements, demonstration plans and evaluation criteria,
iteration plans, software process, metrics analysis
Software
engineering
11 Architecture engineering, design walkthrough coordination, NAS
CSCI development, metrics definition and assessment,
demonstration planning and integration
Development 38 Development, testing, documentation, and maintenance of
application components
Testing,
assessment, and
deployment
24 Release management; formal test preparation, conduct, and
reporting; test scenario development; change management;
deployment
Infrastructure 11 System administration, hardware and software resources, toolsmithing,
tool integration
Total software
activities
100 Cost expenditures, including hardware and software tools – in
the infrastructure element, travel, and other direct costs
These data were extracted from the final WBS cost collection runs.
The next-level elements are described in the following table:
TABLE D-9. Common Subsystem cost expenditures by lower level WBS element
WBS ELEMENT COST (%) ACTIVITIES AND ARTIFACTS
Software project management 6 Customer interface, contracts,
administrations
Software engineering 5 Requirements coordination, chief engineer
Specifications 4 CSCI SRS development
Demonstrations 3 Plans, integration, reports
Tools/metrics 3 Tools, metrics collection
NAS CSCI 3 Middleware, 20 KSLOC
Integration and test management 4 Test coordination, management
BIT testing 3 Integration smoke testing
EST testing 9 Formal test plans, testing, reports
FQT testing 6 Formal test plans, testing, reports
Configuration management and
test-bed control
3 Release management, integration
Environment 11 Hardware, software, system administration
Development management 5 CSCI applications management
SSV CSCI 11 Architecture, system software, 160 KSLOC
DCO CSCI 9 Display interface applications, 70 KSLOC
CCO CSCI 9 Communications applications, 80 KSLOC
TAS CSCI 2 Test and exercise applications, 10 KSLOC
CMP CSCI 4 Mission algorithm applications, 15 KSLOC
Total software activities 100 All software-related expenses
The following are some noteworthy data points:
􀀻 Some of the elements in table D-9 were split across elements in table D-8 to extract the
activities at the project management level.
􀀻 The overall test team effort is relatively low compared with that of projects using
conventional process.
􀂾 The main reason is that the architecture team delivered an integrated software product
to the test and assessment team, which was responsible for testing the integrated quality
of the evolving product.
􀀻 CCPDS-R used an efficient environment representing 11% of the total cost of the
effort.
􀀻 Overall maintenance – total rework effort expended – was only 5% of the total cost. It
was
tracked in the individual CSCI WBS elements, though not explicitly specified.
To compare varying levels of productivity in a normalized manner, individual CSCI costs

can be
compared with each other and other metrics, also.
These comparisons need to be tempered by management understanding of subjective
attributes
such as team competence, requirements volatility, CSCI complexity, and other non-
comparable
factors.
D.8 OTHER METRICS
More global perspectives of CCPDS-R project performance like software size evolution,
subsystem process improvements, SCO resolution profile, and CSCI productivities and
quality
factors are presented here.
D.8.1 SOFTWARE SIZE EVOLUTION
The software sizes of the Common Subsystem and individual CSCIs were tracked
monthly and
were derived directly from the evolving metrics files.
There was a large amount of code growth from the original contract bid – 1,50,000 SLOC
– to
the delivered product – 3,55,000 SLOC, with no substantial increase in the software
development
budget.
There were two reasons for this growth:
1. The method for counting source lines was changed to provide a better balance in
estimating the engineering effort and to be consistent with the counting method of Ada
COCOMO.
2. Several automatic code generation tools were developed to get verbose source-code
without much human-generated input lines.
These tools were used for the straightforward generation of display formats, message
validation processing, and socket/circuit bookkeeping functions.
♦ They represented about 14,000 SLOC of tools,
♦ Requiring another 20,000 SLOC of input data files, and
♦ The output of these tools was about 2,00,000 SLOC of operational software.
These code generation tools resulted in about a fivefold return of investment.
The following table summarizes the total code growth:
TABLE D-10. Common Subsystem CSCI sizes
CSCI CONTRACT
AWARD
DELIVERED AUTOMATICALLY
PRODUCED
NAS 20,000 20,000
SSV 18,000 1,60,000 1,40,000
DCO 48,000 70,000 18,000
TAS 17,000 10,000 4,000
CMP 23,000 15,000
CCO 24,000 80,000 40,000
Totals 1,50,000 3,55,000 2,02,000
The primary reason for the increase in SLOC was the change in the counting rules.
At contract award time, a simple semicolon count was used.
This approach was transitioned to the following counting procedure:
􀂾 Within an Ada specification part, each carriage return counted as one SLOC.
􀂾 Four coding standards allowed the SLOC counting to be consistent:
1. Each parameter of a subprogram declaration is listed on a separate line.
The effort in the design of a subprogram interface is generally proportional to the
number of parameters.
2. For custom enumeration types – like socket names and system states – and record
types,
each enumeration or field is listed on a separate line.
Custom types involve custom design and engineering, resulting in an increased SLOC.
3. For predefined enumeration types – like keyboard keys and compass directions,
enumerations are listed on the fewest number of lines without loss of readability.
4. Initialization of composite objects – like records and arrays – is listed with one
component per line.
Each of these assignments represents a custom statement; an “others” clause is used for
non-custom assignments.
􀂾 Within Ada bodies, each semicolon counts as one SLOC.
􀂾 Generic instantiations count one line for each generic parameter.
This definition treats declarative – specification – design more sensitively than it does
executable
– body – design.
This definition provided a consistent and adequate measure, though it is not a perfect
definition.
􀂾 The components responsible for the change in the definition of SLOC
􀀻 The SAS packages in SSV contained a network definition consisting of all the process
definitions, task definitions, socket definitions, and socket connections.
These packages contained a number of record definitions, custom-enumerated types, and
record and array field initializations in specification parts.
The source code for these elements consisted of more than 50,000 cariiage returns but
only a few hundred semicolons.
As the engineering effort involved with these packages was much more like the effort
associated with 50,000 SLOC, there was a need to change.
􀀻 The second component, with similar rationale, was the same global message types.
These packages – numbering about 300 different record types – represented the majority
of data exchanged across SAS objects.
To allocate budgets properly and to compare productivities of different categories, a
method for
normalizing them was devised.
The result was an extension of the COCOMO technique for incorporating reuse, called
equivalent SLOC (ESLOC).
ESLOC converts the standard COCOMO measure of SLOC into a normalized measure
that is
comparable on an effort-per-line basis.
The need for this new measure arises in budget allocation and productivity analysis for
mixtures
of newly developed, reused, and tool-produced source code.
For example, a 10,000-SLOC display component that is automatically produced from a
tool by
specifying 1,000 lines of display formatting script should not be allocated the same
budget as a
newly developed 10,000-SLOC component.
The following table defines the conversion of SLOC to ESLOC on CCPDS-R:
TABLE D-11. SLOC-to-ESLOC conversion factors
SLOC
FORMAT
DESIGN
NEW = 40%
IMPLEMENT
NEW = 20%
TEST
NEW = 40%
ESLOC
Commercial 0% 0% 0% 0%
New 40% 20% 40% 100%
Reused 20% 5% 30% 55%
Automated 0% 0% 40% 40%
Tool input 30% 10% 10% 50%
The rationale for these conversion factors included:
􀀈 Commercial off-the-shelf components do not contribute to the ESLOC count.
The integration of these components scales up with the amount of newly developed
interfacing software.
􀀈 New software must be developed from scratch.
It requires complete design, implementation, and test efforts, and has an ESLOC
multiplier of
100% (1 to 1 conversion).
􀀈 Reused components represent code previously developed for a different application to
be
modified to suit the current application.
The conversion provided above is a simple rule of thumb, instead of the methods to be
applied on individual instances.
Reused software required 50% of the design effort, 25% of the implementation effort,
and
75% of the test effort.
Normalized across the 40/20/40 allocations of new software and it results in a total of
55%.
􀀈 Automated components require a separate source notation [the tool input format] as
input to a
tool that automatically produces the resulting SLOC.
Automated source code becomes part of the end-product; hence it needs to be fully
tested.
The design and implementation effort is set to zero.
If the automation tool is to be developed, its SLOC count should be included in the new
category.
The resulting conversion factor is 40% SLOC-to-ESLOC ratio.
􀀈 Tool input can take on many diverse forms.
CCPDS-R had input files for the architecture definition, display definitions, and message
validation.
These higher level abstraction formats were converted using 75% of the design effort,
50%
of the implementation effort, and 25% of the test effort.
The resulting conversion factor 50% SLOC-to=ESLOC ratio.
The development of a few code production tools reduced the total ESLOC of the
Common
Subsystem by 78,000 lines, as indicated in the table below:
FIGURE D-12. Common Subsystem CSCI sizes in ESLOC
CSCI DELIVERED
SLOC
TOOLPRODUCED
TOOL
INPUTS
DEVELOPED
TOOLS
SIZE
(ESLOC)
NAS 20,000 20,000
SSV 1,60,000 1,40,000 20,000 15,000 1,01,000
DCO 70,000 18,000 6,000 6,000 68,800
TAS 10,000 4,000 7,600
CMP 15,000 15,000
CCO 80,000 40,000 12,000 3,000 65,000
Totals 3,55,000 2,02,000 38,000 24,000 2,77,400
ESLOC was analyzed solely to ensure that the overall staffing and budget allocations,
negotiated
with each CSCI lead, were relatively fair.
These ESLOC estimates were input to cost modeling analyses that incorporated the
relative
complexity of each CSCI and other COCOMO effort adjustment factors.
This code counting process provided a useful perspective for discussing several of the
engineering trade-offs being evaluated.
After the 1st year, the SLOC counts were stable and well correlated to the schedule
estimating
analyses performed throughout the project life cycle.
CCPDS-R illustrates why SLOC is a problematic metric for measuring software size, and
at the
same time is an example of a complex system in which SLOC metrics worked very
effectively.
This section on software size is a good example of the issues associated with transitioning
to
component-based development.
Projects can and must deal with heterogeneous measurements of size, but there is no
industryaccepted
approach.
So, project managers need to analyze carefully such important metrics definitions.
D.8.2 SUBSYSTEM PROCESS IMPROVMENTS
Real process improvements should be evident in subsequent project performance.
CCPDS-R is a perfect case study for illustrating this trend, as it comprised of three
separate
projects.
The Common Subsystem subsidized much of the groundwork for the PDS and
STRATCOM
subsystems – namely, the process definition, the tools, and the reusable architecture
primitives.
With each successive subsystem, productivity and quality improved significantly.
This is the expectation for a mature software process such as the one developed and
evolved on
CCPDS-R.
The CCPDS-R subsystems had consistent measures of human generated SLOC and
homogeneous processes, teams, and techniques – making comparison of productivities
possible.
Cost per SLOC is taken as the normalized unit of measure to compare productivities.
Relative costs among subsystems are taken to be most relevant.
The PDS subsystem was delivered at 40% of the cost per SLOC of the Common
Subsystem, and
the STRATCOM Subsystem at 33%.
This is one of the real indicators of a level 3 or level 4 process.
The following table summarizes the SCO traffic across all CSCIs at month 58:
TABLE D-13. CCPDS-R subsystem changes by CSCI
CSCI TOTAL
SCOs
OPENED
SCOs
CLOSED
SCOs
REJECTED
SCOs
AVERAGE
SCRAP
(SLOC/SCO)
AVERAGE
REWORK
(HOURS/SCO)
Common Subsystem
NAS 236 1 197 38 30 15
SSV 1,200 16 1,004 180 24 16
DCO 526 10 434 82 30 15
TAS 255 0 217 38 40 11
CMP 123 2 105 16 24 35
CCO 435 1 406 28 64 22
PDS Subsystem
PSSV 297 11 231 55 25 8
PDCO 167 10 126 31 25 21
PCO 73 0 72 1 20 10
STRATCOM Subsystem
SSSV 531 30 401 100 18 10
SDCO 339 11 286 42 16 14
STAS 60 0 50 10 20 9
SMP 327 17 299 10 30 9
SCO 180 1 160 19 40 8
SCG 61 6 51 4 85 27
Other
Support 648 2 546 100 Not tracked Not tracked
Test 376 1 356 19 Not tracked Not tracked
Operating
system/
vendor
223 13 161 49 Not tracked Not tracked
Totals 6,056 132 5,102 822 32 13
By the 58th month the Common Subsystem was beyond its FQT and had processed a few
SCOs
in a maintenance mode to accommodate engineering change proposals.
The PDS and STRATCOM subsystems were into their test phases.
For completeness, the table provides entries for support, test, and operating
system/vendor.
Support included code generation tools, configuration management tools, metrics tools,
and
standalone test drivers; test included software drivers used for requirements verification.
Table D-13 shows that the values of the modularity metric – average scrap per change –
and the
adaptability metric – average rework per change – were generally better in the subsequent
subsystems than they were in the Common Subsystem.
The only exception was the SCG CSCI, a special communications capability needed in
the
STRATCOM subsystem that did not have a counterpart in the other subsystems and was
uniquely complex.
CCPDS-R demonstrated the true indicator of a mature process.
With each subsequent subsystem, performance – as measured by quality, productivity, or
time to
market – improved.
CCPDS-R was subjected to a number of SEI software capability evaluations over its
lifetime,
and the project’s process maturity contributed to a level 3 or higher assessment.
These performance improvements were not due solely to a mature process.
Stakeholder teamwork and project investments in architecture middleware and process
automation were equally important to overall project success.
D.8.3 SCO RESOLUTION PROFILE

The average change costs evolved over time into a fairly constant value of 16 hours per
change.
This effort included analysis time, redesign, recode, and retest of the resolution.
The following figure provides a profile of changes in an interesting perspective:
D.8.4 CSCI PRODUCTIVITY AND QUALITY FACTORS
The following table summarizes some of the CCPDS-R CSCI quality and productivity
data:
TABLE D-14. Common Subsystem CSCI summary
PRODUCTIVITY
(STAFFMONTHS)
CSCI COMPLEXITY
SLOC SLOC ESLOC SCRAP
(SLOC/
SCO)
REWORK
(HOURS/
SCO)
NAS: complex
middleware
Very high 20,000 260 260 30 15
SSV: architecture,
systems software
High 1,60,000 320 200 24 16
DCO: display, user
interface
Moderate 70,000 170 160 30 15
TAS: test and
simulation
Low 10,000 110 75 40 11
CMP: mission
algorithms
Moderate 15,000 100 100 24 35
CCO: external
communications
High 80,000 170 140 64 22
Total: missile
warning subsystem
High 3,55,000 200 160 24 16
Productivities for the CSCIs are not absolute.
For comparison purposes, they are normalized relative to the overall subsystem
productivity.
The subsystem productivity is based on a total effort of approximately 1,800 staff-
months.
This includes all management, development, and test resources.
The individual productivities of each CSCI were normalized.
Productivities are described from two perspectives: SLOC per staff-month and ESLOC
per staff
month.
These data lead to the following conclusions:
􀂾 NAS was an extremely complex software engineering problem, requiring and
achieving
both high performance and reusability.
It had an exceptional team, was based on an existing prototype, and had adequate
schedule.
􀂾 SSV had high absolute productivity because the automatically generated code, from
custom
CASE tools, was contained mostly within this CSCI.
The above-average team on SSV also contributed to the high productivity.
43%
18%
16%
12%
9%
2% < 1%
< 4 hours 4 to 8 8 to 16 16 to 40 40 to 80 80 to 160 >160 hours
FIGURE D-16.
Common Subsystem
CSCI summary
􀂾 DCO was fairly average on all counts but accommodated substantial requirements
volatility
in the display interface without a contract amendment.
The design of this CSCI and the performance of the team were better than the numbers
would indicate.
􀂾 TAS had a low productivity despite being the simplest and most well-understood
software.
The main reason was that the plan for task resources was less ambitious than the plans for
other teams.
Another reason was that the TAS team was locate off-site, with highly constrained
development environment resources.
􀂾 CMP had a high cost of change and low productivity, and not for any technical
reasons.
To ensure technical integrity, the inherent missile warning algorithm changes were
closely
scrutinized by many stakeholders.
The coordination of this process resulted in high overhead in CMP productivity and
changes.
􀂾 CCO had the worst quality metrics.
This was due to a design that did not foresee a major message set change and therefore
resulted in broad and hard-to-resolve breakage.
The CCO team was also the most difficult to transition – culturally – to the process,
metrics,
and demonstration approach used on CCPDS-R.
Overall, this level of productivity and quality was approximately double TRW’s standard
for
previous command center software projects.
D.9 PEOPLE FACTORS
CCPDS-R used two unique approaches to managing its people:
① The core team concept – focusing on leveraging the skills of a few experts across the
entire
team.
② The attrition-avoiding strategy.
The TRW management instituted an award fee flow-down program as an incentive to
people to
remain on the project for a long time.
As a result, there was very little attrition of people across the Common Subsystem, and
also
during the PDS and STRATCOM subsystems, as they overlapped enough with the
Common
Subsystem.
D.9.1 CORE TEAM
The core team of the CCPDS-R software organization was
􀀌 Established early in the concept definition phase
􀀌 To deal explicitly with the important 20% of the software engineering activities having
high return on investment.
In particular, the core team with fewer than 10 members was responsible for the
following:
1.Developing the highest leverage components – mostly within the NAS CSCI.
These components resolved the difficult computer science related issues like real-time
scheduling, interprocess communications, run-time configuration management, error
processing, and distributed systems programming.
Encapsulating these complex issues in a small number of high- leverage components
resulted
in the mainstream components becoming simpler and less dependent on experts.
2.Setting standards and procedures for design walkthroughs and software artifacts.
The core team represented the frontline pioneers for most of the software activities by
conducting any project workflow first, or building the first version of most artifacts.
The core team was intimately involved with setting precedent in standard for activities or
the
formats/contents of any artifact.
3.Disseminating the culture throughout the software organization.
The core team was a single, tight-knit team during the inception and most part of the
elaboration phases.
As the process and architecture stabilized, the team started to migrate, with several of its
members taking on technical leadership roles on the various development and assessment
teams.
During construction and transition, a few members of the core team maintained the
architecture integrity across the entire project.
These team and personnel transitions were the mechanism for maintaining a common
culture.
D.9.2 AWARD FEE FLOW-DOWN PLAN
The TRW management and the government (customer) were concerned about recruiting
and
retaining a stable, quality software team for the CCPDS-R project.
The project also needed to obtain and develop Ada experience, and Ada experience was a
scarce
resource at the time of the inception of CCPDS-R.
TRW proposed an innovative profit sharing approach to enhance the project’s ability to
attract
and retain a complementary team.
The basic premise of the CCPDS-R award fee flow-down plan was that employees would
share
in the profitability of the project.
[Award fees are contract payments above the cost basis. They are tied to project
performance
against predefined criteria.]
It was agreed to allocate a portion of the award fee pool at each major milestone to be
directly
given to the employees.
The relative contribution and longevity on the project of the individuals were the criteria
for the
distribution of the pool.
The flow-down plan was to achieve the following objectives:
􀂾 Reward the entire team for excellent performance
􀂾 Reward different peer groups relative to their overall contribution
􀂾 Minimize attrition of good people
The plan was complex, but its implementation was simple.
This plan, in the end, achieved its goals in minimizing attrition.
One flaw in the plan was that the early award fees (at PDR and CDR) were far less
substantial
than the later award fees.
So, the teams responsible for the construction and transition phases got more than did
those
working on the inception and elaboration phases.
The basic operational concept of the plan:
􀀈 Management defined the various peer groups – systems engineering, software
engineering,
business administration, and administration.
􀀈 Every 6 months, the people within each peer group ranked one another with respect to
their
contribution to the project.
The manager of each peer groups also ranked the team members.
The manager compiled the results into a global performance ranking of the peer group.
􀀈 Each award fee was determined by the customer at certain major milestones.
Half of each award fee pool was distributed to project employees.
􀀈 The algorithm for the distributions is:
o The general range of additional compensation relative to each employee’s salary was
about 2% to 10% every year.
o The distribution to each peer group was relative to the average salary of the group.
o The differences in employees’ salaries within each group defined the relative
differences in the expected contributions of employees toward overall project success.
o The distribution within a peer group had two parts:
􀂃 Half of the total peer group pool was distributed equally among all.
􀂃 The other half was distributed to the top performers within the group as
defined by the group’s self-ranking.
􀂃 Management had some discretion in the amounts and ranges.
The true impact of this award fee flow-down plan is hard to determine.
But, it made a difference in the overall teamwork and in retaining the critical people.
The peer ranking worked well in discriminating the top performers.
Excepting a few surprises, the peer rankings matched management’s perceptions closely.
TRW shared a little less than 10% of its overall profit with its employees.
The return on this investment would be considered high by all stakeholders.
D.10 CONCLUSIONS
TRW and the Air Force have documented the successes of architecture-first development
on
CCPDS-R.
This project achieved two-fold increases in productivity and quality along with on-
budget, onschedule
deliveries of large mission-critical systems.
The success of the CCPDS-R is due to the balanced use of modern technologies, modern
tools,
and an iterative development process.
The following table summarizes the dimensions of improvement incorporated into the
CCPDS-R
project:
TABLE D-15. CCPDS-R technology improvements
PARAMETER MODERN SOFTWARE PROCESS CCPDS-R APPROACH
Environment Integrated tools
Open systems
Hardware performance
Automation
DEC/Rational/Custom tools
VAX/DEC-dependent
Sever VAX family upgrades
Custom-developed management
system, metrics tools, code auditors
Size Reuse, commercial components
Object oriented
Higher level languages
CASE tools
Distributed middleware
Common architecture primitives,
tools, processes across all subsystems
Message-based, object-oriented
architecture
100% Ada
custom automatic code generators for
architecture, message input/output,
display format source code
Early investment in NAS development
for reuse across multiple subsystems
Process Iterative development
Process maturity models
Architecture first
Acquisition reform
Training
Demonstration, multiple builds, early
delivery
Level 3 process before SEI CMM
definition
Executable architecture baseline at
PDR
Excellent customer-contractor-user
teamwork; highly tailored 2167A for
iterative development
Mostly on-the-job training and
internal mentoring
The resulting efficiencies were largely attributable to a major reduction in the software
scrap and
rework (less than 25%) enabled by an architecture-first focus, an iterative development
process,
an enlightened and open-minded customer, and the use of modern environments,
languages, and
tools.
The Common Subsystem subsidized much of the groundwork for the PDS and
STRATCOM
subsystems.
This investment paid significant returns on the subsequent subsystems, in which
productivity and
quality improved.
This is the economic expectation of a mature software process as that developed and
evolved on
CCPDS-R.
Questions on this chapter/appendix:

1. Explain the context of the CCPDS-R project.
2. Give an overview of the Common Subsystem of the CCPDS-R project.
3. Sketch the project organization of CCPDS-R.
4. Explain the six computer software configuration items (CSCIs) of Common
Subsystem.
5. Explain the overview of the CCPDS-R macroprocess, milestones, and schedule.
6. Explain the risk management in CCPDS-R.
7. Explain the basic activities sequence for an individual build as par of incremental
design
process of the CCPDS-R project. (P 315-317/ Fig D-6/P 315)
8. Explain the component evolution from creation through turnover in CCPDS-R. (P 319-
320)
9. Explain the steps in the incremental test process of CCPDS-R. (P 321-323, Fig D-7/P
322)
10. Explain the DOD-STD-2167A artifacts. (P 323-326, Tables D-4/P 325, D-5/P326)
11. Explain how demonstration-based assessment was beneficial in CCPDS-R. (P326-
336)
12. Explain how core metrics were developed in CCPDS-R. (P 337)
13. Explain how development progress was measured in CCPDS-R (P338-340, Fig D-
9/P339,
Fig D-10/P 340)
14. Explain the test progress throughout the CCPDS-R project. (P340-348)
15. Explain the metrics of size, process improvements, SCO resolution, and productivity
and
quality factors as used in CCPDS-R project. (P 348-352)
16. Explain the approaches used in CCPDS-R for managing its people. (P356-359)
17. Explain the award fee flow-down approach and how it was used in CCPDS-R. (P
358-59)
18. Analyze how adaptation of modern process and iterative development model has
contributed to the success of the CCPDS-R project. (P 359-362)

Software Project Management

Uploaded by

Copyright:

Available Formats

Software Project Management

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Software Project Management

Uploaded by

Copyright:

Available Formats

SOFTWARE PROJECT MANAGEMENT (SPM)

The steps to be followed for this type of program design are:

􀁯 During early phases documentation is the only design.

Table 1-1. Expenditures by activity for a conventional software project

10. 80% of the contribution comes from 20% of the contributors.

PART – I SOFTWARE MANAGEMENT RENAISSANCE Page 13 of 187

PART – I SOFTWARE MANAGEMENT RENAISSANCE Page 15 of 187

PART – I SOFTWARE MANAGEMENT RENAISSANCE Page 16 of 187

PART – I SOFTWARE MANAGEMENT RENAISSANCE Page 17 of 187

Microsoft’s success on the PC platform is a counter example, to prove the point of

􀃠 Project scrap and

The primary focus of process improvement should be on achieving an adequate solution

With software engineers, it is difficult to discriminate the intangible (or immeasurable)

In practice selling requires continuous negotiation, compromise, and empathy.

Round-trip engineering describes the environment support needed to change an artifact

Some dimensions of quality improvement are:

d) Integration and test. Serious performance problems are uncovered, necessitating

A significant reengineering of the software development process is taking place in the

In a rapidly growing industry technology fads are difficult to distinguish from

4.2 THE PRINCIPLES OF MODERN SOFTWARE

10. Establish a configurable process that is economically scalable.

TABLE 4-1. Modern process approaches for solving conventional problems

The phases are named to depict the state of the project.

􀀈 Synthesizing the architecture.

􀀈 Elaborating the architecture and selecting components.

This phase could involve any of the following activities:

Questions on this chapter:

Conventional software projects focused on the sequential development of software

Design is the focus of elaboration phase,

In the project management course, three engineering artifacts are to be explicitly

Evaluating quality through human review of abstract descriptions is a highly subjective

Software architecture is the central design problem of a complex software system.

7.2 ARCHITECTURE: A TECHNICAL PERSPECTIVE

Design: names, attributes, structures, behaviors, groupings, and relationships of

Most process descriptions use sequences of activities as representation format.

Questions on this chapter:

Life-cycle Objectives Milestone

Initial Operational Capability Milestone

9.2 PERIODIC STATUS ASSESSMENTS

Questions on this chapter

Project planning requires an iterative process.

􀂾 Ratio of productive testing versus (unproductive) integration

AD Transition phase management

Software lines of business are motivated by return on investment, new business

Software Engineering Process Authority < SEPA >

􀂔 The infrastructure can range from trivial to highly entrenched bureaucracies.

The main features of the default organization are as follows:

This encompasses the engineering necessary to

A different set of activities is emphasized in each phase, as follows:

12.2 THE PROJECT ENVIRONMENT

In conventional software management processes, baseline configuration management

Is it a change to a program unit or to a component, file, or a subsystem?

Configuration Control Board [CCB]

The handbook provides a general framework for answering:

The following figure shows an outline for an organizational policy:

An on-line environment accessible by the external stakeholders allows them to participate

Reviews and inspections, breakage/rework assessments, metrics analyses, and beta

The central management issues of complex software to be tackled by a modern software

TABLE 13-1. Overview of the seven core metrics (Continued)

13.2 MANAGEMENT INDICATORS