High quality process lead to high quality product
    High quality software processes
    -   Documented set of steps
    -   Actively managed in optimal sense
    -   Processes are constantly refined by the organisation using metrics
    -   Output from the refined processes should then be consistent and of 
        high quality

    Problems
    -   Many kinds of processes
    -   Each software product is unique in its own way and circumstances
    -   Some software processes can actually hinder product 
        development rather than support it
    -   Need to have a flexible project plan that can be easily 
        changed to fit new circumstances
    -   Need to have a proper mix of processes(must discuss in 
        advance)
    -   Must have a metric(s) to check and assess the project
    -   Employee turnover (retraining)
    -   Software prone to unpredictable and unexpected events 
        (external factors)
    -   Internal polictics ignore processes

Review

1.  -   Assemble a team of reviewers
        -   get project members involved in the review

2.  -   Distribute Documents for review
        -   Choose measurements to be made
        -   assign reviwers their tasks
        -   overview of architecture of system

a.  -   Design or program inspections
    -   Check requirements/design and code with errors checklist

b.  -   Progress Review
    -   Proceeding with schedule vs late/early
    -   Reshuffle resources
    -   Replan

c.  -   Quality Review
    -   Follow ISO9000 standard
    -   Requirements vs Design/Code

3.  -   Do review
        -   document problems during review

4.  -   Follow up steps on the review
        -   Solve problems
        -   Reshuffle resources

Electronic Form

1.  Categorize the "comments" in terms of the software development process
    Have personell names and contacts
2.  Sub-Categorize the "comments" by components
    Have personel names and contacts associated
3.  In each comment provide date/company/name and rank of person
    /contact information of the reviewer
4.  Have a miscellaneous
5.  Have a documentation of follow up procedures for each

Quantitative Metrics

Code Standards

Standard                                        Rationale

Text editors                                    Readability

Character case (all lower case)                 Readability/maintenance

camelHump naming(naming convention)             Readability

Tab spacing                                     Readability/maintenance

Reasonable Comments                             Maintenance

No program jump statements                      Readability/maintenance
                                                /Efficency

Declare variables at beginning of scope/block   readability

Design Metrics

Fan In and Fan Out                              Fan In better (reusability)

Length of code                                  Size of program or class

Cyclomatic complexity                           How much control passing

Length of identifiers                           Meaningful names of
                                                functions/variables
												
Number of comments                              90% of length

Depth of conditional nesting                    How many layers of conditional 
                                                nesting(complexity in 
                                                branching)

Documentation and specification Metrics
Fog Index                                       Documentation length
                                                Precise and to the point (no 
                                                boring stuff)
												
Details                                         Provide enough details and no
                                                ambiguity in the design

Database Quantitative metrics

Customer Complaints                             Count num of

Errors in code/design                           Checklist of common causes
                                                of problems

Design to requirements                          Amount of errors between
                                                design and requirements

Code to requirements                            Amount of errors between
                                                code and requirements

Requirements to Customer Specs                  Amount of errors between
                                                customer specification and
                                                documented requirements

Plan completion checks                          Amount of components completed
                                                on time and on schedule

Resource Usage                                  Access time, memory use ,
                                                resource wastage

Testing                                         Number of bugs