UNIT II

IMPROVING TEAM EFFECTIVENESS

 COCOMO model suggests that the combined
effects of personnel skill and experience can
have an impact on productivity as much as a
factor of four over the unskilled personnel.
 Balance and coverage are two of the most
important features of excellent teams. Whenever
a team is in out of balance then it is vulnerable.
 It is the responsibility of the project manager to
keep track of his teams. Since teamwork is much
more important than the sum of the individuals.
 Boehm – staffing principles:
 The principle of top talent: Use better and fewer
people.
 The principle of job matching: Fit the tasks to the skills
and motivation of the people available.
 The principle of career progression: An organization
does best in the long run by helping its people to self-
actualize.
 The principle of team balance: Select people who will
complement and synchronize with one another.
 The principle of phase-out: Keeping a misfit on the
team doesn’t benefit anyone.
 Boehm – staffing principles

In general, staffing is achieved by these common

methods:
 If people are already available with required skill
set, just take them
 If people are already available but do not have
the required skills, re-train them
 If people are not available, recruit trained people
 If you are not able to recruit skilled people,
recruit and train people
• Staffing of key personnel is very important:-
Project Manager
Software Architect
 Important Project Manager Skills
 Hiring skills: Few decisions are as important as
hiring decisions. Placing the right person in the
right job seems obvious but is surprisingly hard to
achieve.
 Customer-interface skill: Avoiding adversarial
relationships among stake-holders is a prerequisite
for success.
 Decision-making skill: The jillion books written
about management have failed to provide a clear
definition of this attribute. We all know a good
leader when we run into one, and decision-making
skill seems obvious despite its intangible definition.
 Important Project Manager Skills
• Team-building skill: Teamwork requires that a
manager establish trust, motivate progress, exploit
eccentric prima donnas, transition average people
into top performers, eliminate misfits, and
consolidate diverse opinions into a team direction.
• Selling skill: Successful project managers 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
 Important Software Architect Skills:

• Technical Skills: the most important skills for an architect. These

must include skills in both, the problem domain and the solution
domain

• People Management Skills: must ensure that all people

understand and implement the architecture in exactly the way he
has conceptualized it. This calls for a lot of people management
skills and patience.

• Role Model: must be a role model for the software engineers –

they would emulate all good (and also all bad !) things that the
architect does
• All project process consists of

• Productive activities-like modeling, coding ,debugging

etc which contribute directly to the end product.

• Overhead activities- these indirectly support for

developing the end product.
Ex. progress monitoring, risk assessment ,financial
assessment ,personnel training , business
administration etc.
• The objective of process improvement is to
allocate more resources to productive activities
and minimize the impact of overhead
activities on personnel,computers,schedule etc.

• The primary goal here is to achieving a good

solution with minimum no of iterations and
eliminating scrap and rework to the possible
extent.
IMPROVING AUTOMATION THROUGH SOFTWARE ENVIRONMENTS

 Tools and environment has a direct influence on

productivity.
 Tools may be editors,debuggers,compilers ,test tools etc.
 Manual tasks are inefficient and error prone.
 Good environment and tools improve productivity, quality
and allow the use of modern techniques.
 The environment must provide automation of requirements
mgmt, document automation, target programming tools,
automated regression testing etc.
 The environments must allow roundtrip engineering for
iterative development which is a combination of forward
and reverse engineering.
 IMPROVING AUTOMATION THROUGH
SOFTWARE ENVIRONMENTS
• Forward Engineering –Automation of one
engineering artifact from another, more
abstract representation
Ex:Compiler
• Reverse Engineering – Generation or
modification of a more abstract
representation from an existing artifact.
 IMPROVING AUTOMATION THROUGH SOFTWARE
ENVIRONMENTS

• Automation of the design process improves

quality and enables to estimate costs and
schedules and improves overall productivity
using smaller teams.
• The combined effect of all tools tend to be
less than 40% in productivity and there must
be corresponding change in the process.
 ACHIEVING REQUIRED QUALITY

• Modern practices have impact not only on the

productivity and cost but also quality.
Quality improvements with modern process
Quality improvements with modern
process
 Key Practices to improve s/w Quality

 Focus on driving requirements and critical use cases early in the life cycle.

 Use metrics and indicators to measure the progress and quality of the
architecture .

 Provide integrated life cycle environments with automation tools for

testing, documentation , change mgmt etc.

 Use visual modeling and HLLs which support abstraction, reuse, reliable
programming.

 Early and continuous insight into performance issues through

demonstration based evaluations
PEER INSPECTIONS: A PRAGMATIC VIEW:
PEER INSPECTIONS: A PRAGMATIC VIEW:
 THE OLD WAY AND THE NEW

• Over the past two decades software

development is a re-engineering process. Now
it is replaced by advanced software
engineering technologies.
• This transition was motivated by the
unsatisfactory demand for the software and
reduced cost.
 THE PRINCIPLES OF CONVENTIONAL SOFTWARE ENGINEERING

• Based on many years of software

development experience, the software
industry proposed so many principles (nearly
201 by – Davis’s). Of which
• Davis’s top 30 principles are:
 Davis’s top 30 principles
1).Make quality : Quality must be quantified and mechanisms put into
place to motivate its achievement.

2)High-quality software is possible: In order to improve the quality

of the product we need to involving the customer, select the
prototyping, simplifying design, conducting inspections, and hiring
the best people.

3). Give products to customers early: No matter how hard you try to
learn user’s 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.
 Davis’s top 30 principles
4) Determine the problem before writing the requirements:
Whenever a problem is raised most engineers provide a
solution. Before we try to solve a problem, be sure to explore
all the alternatives and don’t be blinded by the
understandable solution.

5) Evaluate design alternatives: After the requirements are

agreed upon, we must examine a variety of architectures and
algorithms and choose the one which is not used earlier.

6) Use an appropriate process model: For every project, there

are so many prototypes (process models). So select the best
one that is exactly suitable to our project.
 Davis’s top 30 principles
7) Use different languages for different phases: Our
industry’s main aim is to provide simple solutions to
complex problems. In order to accomplish this goal
choose different languages for different
modules/phases if required.
8) Minimize intellectual distance: We have to design
the structure of a software is as close as possible to
the real-world structure.
9) Put techniques before tools: An un disciplined
software engineer with a tool becomes a dangerous,
undisciplined software engineer.
 Davis’s top 30 principles
10) Get it right before you make it faster: It is
very easy to make a working program run faster
than it is to make a fast program work. Don’t
worry about optimization during initial coding.
11) Inspect the code: Examine the detailed
design and code is a much better way to find
the errors than testing.
12) Good management is more important than
good technology
 Davis’s top 30 principles
13) People are the key to success: Highly skilled people with
appropriate experience, talent, and training are key. The right
people with insufficient tools, languages, and process will
succeed.

14) Follow with care: Everybody is doing something but does not
make it right for you. It may be right, but you must carefully
assess its applicability to your environment.

15) Take responsibility: When a bridge collapses we ask “what did

the engineer do wrong?”. Similarly if the software fails, we ask the
same. So the fact is in every engineering discipline, the best
methods can be used to produce poor results and the most out of
date methods to produce stylish design.
 Davis’s top 30 principles
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.
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.
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.
 Davis’s top 30 principles
19) Design for change. The architectures,
components, and specification techniques you
use must accommodate change.
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.”
21. Use tools, but be realistic. Software tools
make their users more efficient.
 Davis’s top 30 principles
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.

23. Encapsulate. Information-hiding is a simple, proven concept

that results in software that is easier to test and much easier to
maintain.

24. Use coupling and cohesion. Coupling and cohesion are the
best ways to measure software’s inherent maintainability and
adaptability.
 Davis’s top 30 principles
25. Use the McCabe complexity measure. Although there
are many metrics available to report the inherent
complexity of software, none is as intuitive and easy to
use as Tom McCabe’s.
26. Don’t test your own software. Software developers
should never be the primary testers of their own
software.
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.
 Davis’s top 30 principles
28. Realize that software’s entropy increases. Any
software system that undergoes continuous
change will grow in complexity and become more
and more disorganized.
29. People and time are not interchangeable.
Measuring a project solely by person-months
makes little sense.
30) Expert excellence. Your employees will do much
better if you have high expectations for them.
 THE PRINCIPLES OF MODERN SOFTWARE MANAGEMENT

1) Base the process on an architecture-first

approach: (Central design element)- Design and
integration first, then production and test
2) Establish an iterative life-cycle process: (The risk
management element)
Risk control through ever-increasing function,
performance, quality. With today’s sophisticated
systems, it is not possible to define the entire
problem, design the entire solution, build the
software, then test the end product in sequence.
 THE PRINCIPLES OF MODERN SOFTWARE MANAGEMENT

• Instead, and iterative process that refines the

problem understanding, an effective solution,
and an effective plan over several iterations
encourages balanced treatment of all
stakeholder objectives.
• Major risks must be addressed early to
increase predictability and avoid expensive
downstream scrap and rework.
 THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
3) Transition design methods to emphasize
component-based development: (The technology
element)
Moving from LOC mentally to component-based
mentally is necessary to reduce the amount of
human-generated source code and custom
development. A component is a cohesive set of
preexisting lines of code, either in source or
executable format, with a defined interface and
behavior
THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
4) Establish a change management
environment: (The control element)
- Metrics, trends, process instrumentation The
dynamics of iterative development, include
concurrent workflows by different teams
working on shared artifacts, necessitates
objectively controlled baseline.
 THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
5) Enhance change freedom through tools that
support round-trip engineering: (The
automation element)- Complementary tools,
integrated environment
• Round-trip engineering is the environment
support necessary to automate and
synchronize engineering information in
different formats. Change freedom is
necessary in an iterative process.
 THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
6) Capture design artifacts in rigorous, model-based
notation:
• A model-based approach supports the evolution of
semantically rich graphical and textual design
notations.
• Visual modeling with rigorous notations and formal
machine- process able language provides more
objective measures than the traditional approach of
human review and inspection of ad hoc design
representations in paper doc.
 THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
7) Instrument the process for objective quality
control and progress assessment:
• Life-cycle assessment of the progress and
quality of all intermediate product 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.
 THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
8) Use a demonstration-based approach to
assess intermediate artifacts:
• Transitioning from whether the artifact is an
early prototype, a baseline architecture,
• or a beta capability into an executable
demonstration of relevant provides more
tangible understanding of the design
tradeoffs, early integration and earlier
elimination of architectural defects.
 THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
9) Plan intermediate releases in groups of usage
scenarios with evolving levels of detail:

10) Establish a configurable process that economically

scalable:

No single process is suitable for all software

developments. The process must ensure that there is
economy of scale and ROI.
THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT
THE PRINCIPLES OF MODERN SOFTWARE
MANAGEMENT