ASSIGNMENT 3 (SPM)

Submitted by- Vibhanshu Gaurav

(IMB2020010)

CMM (Capability maturity model)

CMM is a framework which is used to analyse the approach and techniques followed
by any organization to develop software products. It is a methodology used to
develop and refine an organization's software development process. It was
developed by the Software Engineering Institute (SEI) at Carnegie Mellon University
in 1987. The model provides guidelines to further enhance the maturity of the
process used to develop those software products. It is based on profound feedback
and development practices adopted by the most successful organizations worldwide.
Different phases of CMM:
This model describes a strategy for software process improvement that should be
followed by moving through 5 different levels-
 At the initial level, processes are disorganized, even chaotic. Success is likely
to depend on individual efforts, and is not considered to be repeatable,
because processes would not be sufficiently defined and documented to allow
them to be replicated.
 At the repeatable level, basic project management techniques are
established, and successes could be repeated, because the requisite
processes would have been made established, defined, and documented.
 At the defined level, an organization has developed its own standard software
process through greater attention to documentation, standardization, and
integration.
 At the managed level, an organization monitors and controls its own
processes through data collection and analysis.
 At the optimizing level, processes are constantly being improved through
monitoring feedback from current processes and introducing innovative
processes to better serve the organization's particular needs.

KPIs
A Key Performance Indicator (KPI) is a measurable value that businesses use to
determine the success or failure of various campaigns and business objectives.
Software project KPIs can tell how efficient team’s work is and whether the project
management requires improvements. KPIs bring the most value to project
management when they are measured on a regular basis: after some time, they start
showing tendencies in the project’s workflow.  Following are the 6 essential KPIs for
software development team:
1. Writing Stable Code
Writing stable code refers to creating changes to the product that don’t harm the rest
of the business.
If releasing a new feature breaks an existing feature, that can be bad for business.
To avoid that, aim for stable code. Stable code is calm code. Also, when the team
isn’t reacting to the negative upshot of an unstable codebase, they can focus on
developing new features.
2. Writing Testable Code
When we talk about writing testable code, we mean both writing code that is easy for
an automated system to test and also writing those tests. The tests act like
documentation so that changes from a developer will quickly show any errors.
This software development KPI is also important to the business because it can
serve as a measure for how easy it is to onboard new developers. A well-tested
codebase makes things much easier to track when adding a new person to the team.
3. Working on Code Churn
Code churn refers to how often code changes over time. While it is a natural part of
the development cycle, code churn should be minimized where possible.
The less code that needs to change to accommodate a new feature the better. This
measure is also a proxy for how easy change is in the system. The easier change is,
the less risk is involved. Management loves mitigating risk.
4. Writing Simple Code
Writing simple code involves writing in such a way that the intent is clear to both
other developers and the machines running the system.
5. Sharing Knowledge
All of our KPIs for software development teams so far have been technical, but
developers don’t spend all day writing code. Their KPIs should reflect this. When we
talk about sharing knowledge, we mean either developers sharing what they know
with other developers or with the broader team.
The more sharing that is done, via code documentation, collaborative meetings,
sharing of new things learned or articles written, the less management will worry that
only a few key people within the team are gatekeepers to valuable knowledge. 
6. Supporting Each Other
Related to sharing knowledge is supporting people within the immediate and broader
team. Developers are useful for more than writing code. KPIs built around being
good citizens of the company help to integrate the development team with the
company.