案例15.1  引入缺陷预测后更新PSP过程示例

  
　

 

问题提出：
　　缺陷数据不稳定是由以下几个原因造成的。首先是经验问题。缺陷率波动的第二个原因是个体过程不稳定。当为一个新的程序作计划时，先估计出程序可能有多少新的和修改的代码行。然后计算以前开发程序的每千行源代码的平均缺陷数。有了这些数据，就可以计算出在新的程序中的每千行代码的缺陷数。
　　估计出新程序总的缺陷数目之后，就能计算出每个阶段于预计引入排除的缺陷数。用于估计的缺陷总数乘以每个阶段的累计百分比值再除以100就得到每个阶段的缺陷数。这个数就是新的程序在这个阶段的预计缺陷数。这也就是要计算缺陷累计和缺陷累计百分比值的原因。他们为缺陷估计提供了必要的历史数据。
　　当引入缺陷预测后，需要在相应的计划、总结部分增加相应栏，请示例给出更新PSP的过程？

问题解答： 

表15.5  PSP项目计划总结表的示例
学生　　　　　学生Ｘ　　　　　　　　　　　　日期　　　　11/8/96 　 　　。
程序　　　　　　　　　　　　　　　　　　　　程序号＃　　　13 　　　　　。
教师　　　　　先生Ｚ　　　　　　　　　　　　程序设计语言　　Ada　　　　。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　。

总结
计 划
实 际
累 计
Minutes/LOC
　b　　　　5.92　.
p
　　　4.87　　　.
x
　　　　5.73　　　　.
LOC/Hour
　 　 　　10.14　.
q
　　　12.32 　　.
y
　　　　10.49 　　　.
Defects/KLOC
　i　　 　94.79　.
r
　　　106.4　 　.
z
　　　　96.90 　　　.
过程效益
A/FR
程序规模(LOC)
新开发的与更改的
　a　　　　　58　.
o
　　　 47 　　　.
w
　　　　258 　　　　.
最大规模
　a　　　　　72　.
　　　 　 　　　.
　　　　　　　　　　.
最小规模
　a　　　　　41　.
　　　 　 　　　.
　　　　　　　　　　.
开发阶段时间/min
计 划
实 际
累 计
累计百分比
计划
　f　　　72　.
m
　　22　　.
s
　　882　　.
u
　　　6.0　　　.
设计
　f　　　35　.
m
　　24　　.
s
　　151　　.
u
　　　10.2 　　.
编码
　f　　 149　.
m
　　93　　.
s
　　637　　.
u
　　　43.1 　　.
代码复查
　f　　　20　.
m
　　37　　.
s
　　111　　.
u
　　　 7.5 　　.
编译
　f　　　24　.
m
　　 4　　.
s
　　92 　　.
u
　　　 6.2 　　.
测试
　f　　　64　.
m
　　 8　　.
s
　　240　　.
u
　　　16.2 　　.
后置处理
　f　　　33　.
m
　　41　　.
s
　　160　　.
u
　　　10.8 　　.
总计
　f　　 343　.
m
　　229 　.
s
　　1479 　.
u
　　　100.0　　.
最大时间
　f　　 426　.
  
最小时间
　f　　 243　.
  
引入的缺陷
计划
实际
累计
累计百分比
Def./Hour
计划
　 　 　　.
　　　　　.
　　  　　.
　　　　　　.
设计
1
　　1 　　.
　　　　　.
t
　　4 　　.
u
　　16.0　　.
编码
1
　　5 　　.
n
　　5 　　.
t
　　21　　.
u
　 　84.0 　.
代码复查
　　　　　.
　　　　　.
　　　　　.
　　　　　　.
编译
　　　　　.
　　　　　.
　　　　　.
　　　　　　.
测试
　　　　　.
　　　　　　.
总计
j
　　6 　　.
n
　　5 　　.
t
　　25　　.
u
　　100.0 　.
排除的缺陷
计划
实际
累计
累计百分比
计划
　 　 　　.
　　　　　.
　　  　　.
　　　　　　.
设计
　 　 　　.
　　　　　.
　　　　　.
　　　　　　.
编码
　 　 　　.
　　　　　.
　　  　　.
　　　　　　.
代码复查
1
　　2 　　.
n
　　3 　　.
t
　　8 　　.
u
　　32.0　　.
编译
1
　　3 　　.
n
　　2 　　.
t
　　12　　.
u
　　48.0　　.
测试
1
　  1 　　.
　　　　　.
t
　　5 　　.
u
　　20.0　　.
总计
j
　  6 　　.
n
　　5 　　.
t
　　25　　.
u
　　100.0 　.

表15.6  PSP项目计划总结表的示例
学生　　　　　学生Ｘ　　　　　　　　　　　　日期　　　　11/11/96　 　　。
程序　　　　　　　　　　　　　　　　　　　　程序号＃　　　12 　　　　　。
教师　　　　　先生Ｚ　　　　　　　　　　　　程序设计语言　　Ada　　　　。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　。

总结
计 划
实 际
累 计
Minutes/LOC
　　　6.30　　　.
　　　4.93　　　.
b
　　　　5.92　　　　.
LOC/Hour
　 　 9.52　　　.
　　　12.17 　　.
　　　　10.14 　　　.
Defects/KLOC
g
　　　　94.79 　　　.
过程效益
A/FR
程序规模(LOC)
新开发的与更改的
　　　51　　　　.
　　　 58 　　　.
h
　　　　211 　　　　.
最大规模
　　　65　　　　.
最小规模
　　　37　　　　.
开发阶段时间/min
计 划
实 际
累 计
累计百分比
计划
　　 16 　　.
　　18　　.
s
　　66 　　.
e
　　 　5.3 　　.
设计
　　 27 　　.
　　44　　.
s
　　127　　.
e
　　 　10.2　　.
编码
　　 146　　.
　　104 　.
s
　　544　　.
e
　　 　43.5　　.
代码复查
　　 12 　　.
　　38　　.
s
　　74 　　.
e
　　 　5.9 　　.
编译
26
　　11　　.
s
88
e
　　 　7.0 　　.
测试
　　 68 　　.
　　29　　.
s
　　232　　.
e
　　 　18.6　　.
后置处理
　　 26 　　.
　　42　　.
s
　　119　　.
e
　 　　9.5 　　.
总计
　　 321　　.
　　286 　.
s
　　1250 　.
e
　 　 100.0　　.
最大时间
　　 410　　.
最小时间
　　 233　　.
引入的缺陷
计划
实际
累计
累计百分比
Def./Hour
计划
　　 　 　.
　　　　　.
　　　　　.
　　　　　　.
设计
　　 　 　.
　　1 　　.
t
　　4 　　.
u
　　 20.0 　.
编码
　　 　 　.
　　5 　　.
t
　　16　　.
u
　 　80.0 　.
代码复查
　　　　　.
　　　　　.
　　　　　.
　　　　　　.
编译
　　　　　.
　　　　　.
　　　　　.
　　　　　　.
测试
　　　　　.
　　　　　　.
总计
　　　　　.
　　6 　　.
i
　　20　　.
　　100.0 　.
排除的缺陷
计划
实际
累计
累计百分比
计划
　　 　 　.
　　　　　.
　　　　　.
　　　　　　.
设计
　　 　 　.
　　　　　.
　　　　　.
　　　　　　.
编码
　　 　 　.
　　　　　.
　　　　　.
　　　　　　.
代码复查
　　　　　.
　　2 　　.
t
　　5 　　.
k
　　25.0　　.
编译
　　　　　.
　　2 　　.
t
　　10　　.
k
　　50.0　　.
测试
　　 　 　.
　　2 　　.
t
　　5 　　.
k
　　25.0　　.
总计
　　 　 　.
　　6 　　.
t
　　20　　.
　　100.0 　.

    表15.5是学生X更新后的程序13的项目计划总结表，利用学生X在前面编写的程序12的总结数据（表15.6）来生成表15.5的过程可进行如下描述，在这些表中不同的值可用字母来标识数据的来源。首先在计划阶段：

  1. 学生X估计该新程序的规模是58行，最大值是72行，最小值是41行（a）。

  2. 他接下来从程序12的项目计划总结表找到每行的累计分钟数，如表中所示为5.92min.、LOC(b)。他用此时作为程序13计划的开发效率。

  3. 用总的估计的代码行58来估计项目的时间58×5.92＝343.36或343min.（c）。

  4. 学生X计算最大和最小的开发时间，分别用最大和最小规模（a）乘以5.92（b）得到426min.和243min.（d）。

  5. 为了计算各个阶段的时间，他从程序12的总结表中取出累计百分比（e）乘以估计的总计时间343分（c）再除100。就得到每个阶段的时间（f）。为了方便，他对时间进行了取整。

  6. 为了计算总的引入和排除的缺陷数。学生X在项目计划总结表中找到程序12的每千行累计缺陷数是94079(g)。从累计代码行数（h）及累计缺陷数(i)可以得到结果，计算过程如下。

  7. 用每千行缺陷数94.79(i)和计划代码行数58(a)，他计算出估计的缺陷数是94079×58/1000=5.50,即大约6个缺陷（j）。

  8. 基于程序12的引入和排除缺陷的累计百分比值（k），他计算出各个阶段的预计引入和排除的缺陷数（l）。
    这样就完成了程序13的缺陷预测。

学生X在表中登入实际数据，步骤如下：

  1. 根据时间纪录日志登入各个阶段的实际的时间值（m）。

  2. 根据缺陷纪录日志登入实际引入和排除的缺陷数（n）。

  3. 他在最终程序中统计新开发的和修改的程序行是47，把此数纪录到实际列下（o）。

  4. 有了这些数据，他用总计时间229（m）除新开发的和修改的行数47（o）得到每行代码实际时间，即229/49=4.87（p）。

  5. 根据每行代码的实际时间（p）计算出每小时实际代码行数，60/4.87=12.32（q）。

  6. 根据实际缺陷数（n）和实际代码行数（o）计算出每千行实际的缺陷数，1000×5/47=106.49（r）。

  7. 通过把各个阶段的时间与前一个项目的相应累计时间相加，他得到各个阶段的累计时间（s）。

  8. 他把前一个项目的各个阶段的实际缺陷数与累计缺陷数相加得到他引入和排除缺陷的累计值（t）。

  9. 计算累计百分比（u）。

  10. 用累计时间值1479（s）除以新开发的和修改的行数值258（w）得到累计的每行时间，1479/258=5.73（x）。

  11. 用5.73（x）这个值来计算累计每小时代码行数，60/5.73=10.47（y）。 

  12. 最后，他用1000乘累计引入缺陷数（t）在除以累计新的和修改的代码行数（w）得到累计每千行缺陷数，1000×25/258=96.90（z）。

总结：
　　在已更新的项目计划总结表中引入了缺陷预测的内容。在每个项目的计划阶段给出计划值。在每个程序的后置处理阶段计算计划值、实际值和累计每千行代码缺陷数，以便利用这些数据计划下一个项目。