终于有了间茅草棚

void *几用

终于有了间茅草棚 — Mon, 23 Jun 2008 09:05:00 GMT

    自己常用的几种void *的技法，总结一下，大概用三种代表。

    1.实现隐藏：

    不希望暴露数据结构、实现思路时，在头文件里只一个void *的实现体，实现的时候再调用实现体的实现。当然，如果真这么用，最好和内存池结合起来，避免实现体的new/delete内存操作。

.h头文件：
class Sample
{
private:
   void *m_impl;
};

.cpp实现文件：
class SampleImpl
{
private:
...
};

2.数据注入：

有些时候，需要将原本和对象本事无关的数据和对象进行关联，通过在对象身上bind一个void *的指针，非常方便和高效（相对通过map或者其它的对应技术而言）。同样的，最好有一个内存池支持会好很多。

class Sample
{
public:
    void bind( void *data );
    void *bind( void );
private:
    void *m_bind;
};

3.接口简化：

很多人会对一些底层的内容进行浅封装^注1，然后再行操作。在我的实际应用中，大多时候这些浅封装并没有给我带来太多的好处；而且，通常是五花八门、样式繁杂，但实质内容却90％一样。对于做过很长时间上层的我来说，更习惯将封装更面向应用一点，这样一来，底层的能力肯定不能全面暴露出来，真需要时就麻烦了。基于这样的情况，void *成为了选择，对于采用的是浅封装、还是直接底层都可以代表。缺点是扩充者需要知道它真实的涵义（不过，既然要扩充，想不知道扩充的基础底层也不可能）。

通常做法：
#include "./Graphics.h"
class Sample
{
public:
    void draw( Graphics *g );
};

个人做法：
class Sample
{
public:
    void draw( void *g );
};

备注：
浅封装：指那种只是将原底层接口换了个名，重先出现的封装。比如：上面的Graphics只是D3D的设备穿了衣、或者DDRAW的Surface改了名、socket的struct化等。

简单字符串转换

终于有了间茅草棚 — Sat, 05 Jan 2008 07:07:00 GMT

在做字符串、文本操作时，我们时常会需要在wchar_t *和char *之间做转换或搭桥。直接用API，参数太多不容易记住，常常要查文档，浪费不少时间。为了自己方便，对简单的转换写了一个简单的转换包装类。下次或者用得着，帖代码做为保存。
顺便提一下：发现有个东西很好用，std::stringstream系列 (#include < sstream >)；其实，流式操作用起来都很happy，还有iostream、fstream；还有TCP的数据也是流式的。

头文件：string.h

#pragma once
#ifndef __STRING__
#define __STRING__
/**
 * 以下代码由张家旺编写完成于2007-12-5，借用请保留该声明。
 */
namespace useful
{

 class translator
 {
 public:
  static wchar_t *translate(
   const char *str,size_t sub,wchar_t buf[],size_t num );
  static char *translate(
   const wchar_t *str,size_t sub,char buf[],size_t num );
  const wchar_t *translate( const char *str,size_t sub = -1 );
  const char *translate( const wchar_t *str,size_t sub = -1 );
  translator( void );
  ~translator( void );
  static translator &instance( void );
 private:
  void buffer( size_t len )
  {
   if( len > m_len )
   {
    delete[] m_buf;
    m_buf = new char[len];
    m_len = len;
   }
  }
  char *m_buf;
  size_t m_len;
 };

};

#endif //__STRING__

实现文件：string.cpp

#include < string >
#include < windows.h >
#include "./string.h"
#pragma warning( disable : 4267 )
namespace useful
{

 translator::translator( void ) : m_buf( 0 ),m_len( 0 )
 {
 }
 translator::~translator( void )
 {
  delete[] m_buf;
 }
 translator &translator::instance( void )
 {
  static translator impl = translator();
  return impl;
 }

 wchar_t *translator::translate(
  const char *str,size_t sub,wchar_t buf[],size_t num )
 {
  ::MultiByteToWideChar( CP_OEMCP,0,str,sub,buf,num );
  return buf;
 }
 char *translator::translate(
  const wchar_t *str,size_t sub,char buf[],size_t num )
 {
  ::WideCharToMultiByte( CP_OEMCP,0,str,sub,buf,num,0,0 );
  return buf;
 }
 const wchar_t *translator::translate( const char *str,size_t sub )
 {
  if( sub == std::string::npos ) sub = strlen( str );
  buffer( (sub+1) * 2 );
  wchar_t *buf = reinterpret_cast< wchar_t * >( m_buf );
  buf[sub] = L'\0';
  return translate( str,sub,buf,sub );
 }
 const char *translator::translate( const wchar_t *str,size_t sub )
 {
  if( sub == std::wstring::npos ) sub = wcslen( str );
  buffer( sub + 1 );
  m_buf[sub] = '\0';
  return translate( str,sub,m_buf,sub );
 }

};

软件风险管理

终于有了间茅草棚 — Sun, 14 Oct 2007 04:19:00 GMT

这篇文章是我在找资料时找到的。随便抽看了几眼，顿感胸口欢快。所以，把原文抄袭过来，以后再看。

原文地址：http://www.sqlsky.com/soft-engineering/070801/15340/

[作者]：菩提树下的杨过 [来源]：互联网 [收录时间]：2007-8-1 20:15:42

　　摘要：介绍了项目风险管理的过程及常用的工具和方法，讨论了软件项目中经常面临的风险类型和经典的风险管理模型。

　　关键词：项目管理；风险管理；风险管理模型

　　引言

　　软件项目风险是指在软件开发过程中遇到的预算和进度等方面的问题以及这些问题对软件项目的影响。软件项目风险会影响项目计划的实现，如果项目风险变成现实，就有可能影响项目的进度，增加项目的成本，甚至使软件项目不能实现。如果对项目进行风险管理，就可以最大限度的减少风险的发生。但是，目前国内的软件企业不太关心软件项目的风险管理，结果造成软件项目经常性的延期、超过预算，甚至失败。成功的项目管理一般都对项目风险进行了良好的管理。因此任何一个系统开发项目都应将风险管理作为软件项目管理的重要内容。

　　在项目风险管理中，存在多种风险管理方法与工具，软件项目管理只有找出最适合自己的方法与工具并应用到风险管理中，才能尽量减少软件项目风险，促进项目的成功。

　　项目风险管理

　　项目风险管理是指为了最好的达到项目的目标，识别、分配、应对项目生命周期内风险的科学与艺术。项目风险管理的目标是使潜在机会或回报最大化，使潜在风险最小化。风险管理涉及的主要过程包括：风险识别，风险量化，风险应对计划制定和风险监控，如图1所示。风险识别在项目的开始时就要进行，并在项目执行中不断进行。就是说，在项目的整个生命周期内，风险识别是一个连续的过程。

图1 项目风险管理过程

　　（1）风险识别：风险识别包括确定风险的来源，风险产生的条件，描述其风险特征和确定哪些风险事件有可能影响本项目。风险识别不是一次就可以完成的事，应当在项目的自始至终定期进行。

　　（2）风险量化：涉及对风险及风险的相互作用的评估，是衡量风险概率和风险对项目目标影响程度的过程。风险量化的基本内容是确定那些事件需要制定应对措施。。

　　（3）风险应对计划制定：针对风险量化的结果，为降低项目风险的负面效应制定风险应对策略和技术手段的过程。风险应对计划依据风险管理计划、风险排序、风险认知等依据，得出风险应对计划、剩余风险、次要风险以及为其它过程提供得依据。

　　（4）风险监控：涉及整个项目管理过程中的风险进行应对。该过程的输出包括应对风险的纠正措施以及风险管理计划的更新。

　　每个步骤所使用的工具和方法详见表1：

　　表1 风险管理过程中所使用的工具、方法

风险管理步骤	所使用的工具、方法
风险识别	头脑风暴法、面谈、Delphi法、核对表、SWOT技术
风险量化	风险因子计算、PERT估计、决策树分析、风险模拟
风险应对计划制定	回避、转移、缓和、接受
风险监控	核对表、定期项目评估、挣值分析

　　软件项目中的风险管理

　　1、软件项目中的风险

　　软件项目的风险无非体现在以下四个方面：需求、技术、成本和进度。IＴ项目开发中常见的风险有如下几类：

　　（1）需求风险

　　①需求已经成为项目基准，但需求还在继续变化；

　　②需求定义欠佳，而进一步的定义会扩展项目范畴；

　　③添加额外的需求；

　　④产品定义含混的部分比预期需要更多的时间；

　　⑤在做需求中客户参与不够；

　　⑥缺少有效的需求变化管理过程。

　　（2）计划编制风险

　　①计划、资源和产品定义全凭客户或上层领导口头指令，并且不完全一致；

　　②计划是优化的，是"最佳状态"，但计划不现实，只能算是"期望状态"；

　　③计划基于使用特定的小组成员，而那个特定的小组成员其实指望不上；

　　④产品规模(代码行数、功能点、与前一产品规模的百分比)比估计的要大；

　　⑤完成目标日期提前，但没有相应地调整产品范围或可用资源；

　　⑥涉足不熟悉的产品领域，花费在设计和实现上的时间比预期的要多。

　　（3）组织和管理风险

　　①仅由管理层或市场人员进行技术决策，导致计划进度缓慢，计划时间延长；

　　②低效的项目组结构降低生产率；

　　③管理层审查决策的周期比预期的时间长；

　　④预算削减，打乱项目计划；

　　⑤管理层作出了打击项目组织积极性的决定；

　　⑥缺乏必要的规范，导致工作失误与重复工作；

　　⑦非技术的第三方的工作(预算批准、设备采购批准、法律方面的审查、安全保证等)时间比预期的延长。

　　（4）人员风险

　　①作为先决条件的任务(如培训及其他项目)不能按时完成；

　　②开发人员和管理层之间关系不佳，导致决策缓慢，影响全局；

　　③缺乏激励措施，士气低下，降低了生产能力；

　　④某些人员需要更多的时间适应还不熟悉的软件工具和环境；

　　⑤项目后期加入新的开发人员，需进行培训并逐渐与现有成员沟通，从而使现有成员的工作效率降低；

　　⑥由于项目组成员之间发生冲突，导致沟通不畅、设计欠佳、接口出现错误和额外的重复工作；

　　⑦不适应工作的成员没有调离项目组，影响了项目组其他成员的积极性；

　　⑧没有找到项目急需的具有特定技能的人。

　　（5）开发环境风险

　　①设施未及时到位；

　　②设施虽到位，但不配套，如没有电话、网线、办公用品等；

　　③设施拥挤、杂乱或者破损；

　　④开发工具未及时到位；

　　⑤开发工具不如期望的那样有效，开发人员需要时间创建工作环境或者切换新的工具；

　　⑥新的开发工具的学习期比预期的长，内容繁多。

　　（6）客户风险

　　①客户对于最后交付的产品不满意，要求重新设计和重做；

　　②客户的意见未被采纳，造成产品最终无法满足用户要求，因而必须重做；

　　③客户对规划、原型和规格的审核决策周期比预期的要长；

　　④客户没有或不能参与规划、原型和规格阶段的审核，导致需求不稳定和产品生产周期的变更；

　　⑤客户答复的时间(如回答或澄清与需求相关问题的时间)比预期长；

　　⑥客户提供的组件质量欠佳，导致额外的测试、设计和集成工作，以及额外的客户关系管理工作。

　　（7）产品风险

　　①矫正质量低下的不可接受的产品，需要比预期更多的测试、设计和实现工作；

　　②开发额外的不需要的功能(镀金)，延长了计划进度；

　　③严格要求与现有系统兼容，需要进行比预期更多的测试、设计和实现工作；

　　④要求与其他系统或不受本项目组控制的系统相连，导致无法预料的设计、实现和测试工作；

　　⑤在不熟悉或未经检验的软件和硬件环境中运行所产生的未预料到的问题；

　　⑥开发一种全新的模块将比预期花费更长的时间；

　　⑦依赖正在开发中的技术将延长计划进度。

　　（8）设计和实现风险

　　①设计质量低下，导致重复设计；

　　②一些必要的功能无法使用现有的代码和库实现，开发人员必须使用新的库或者自行开发新的功能；

　　③代码和库质量低下，导致需要进行额外的测试，修正错误，或重新制作；

　　④过高估计了增强型工具对计划进度的节省量；

　　⑤分别开发的模块无法有效集成，需要重新设计或制作。

　　（9）过程风险

　　①大量的纸面工作导致进程比预期的慢；

　　②前期的质量保证行为不真实，导致后期的重复工作；

　　③太不正规(缺乏对软件开发策略和标准的遵循)，导致沟通不足，质量欠佳，甚至需重新开发；

　　④过于正规(教条地坚持软件开发策略和标准)，导致过多耗时于无用的工作；

　　⑤向管理层撰写进程报告占用开发人员的时间比预期的多；

　　⑥风险管理粗心，导致未能发现重大的项目风险。

　　2、软件项目风险管理模型

　　针对软件项目中的风险管理问题，不少专家、组织提出了自己的风险管理模型。主要的风险管理模型有：Boehm模型，CRM模型和SERIM模型。

　　2.1 Barry Boehm模型

　　模型：RE=P (UO)*L (UO)

　　其中RE表示风险或者风险所造成的影响，P(UO)表示令人不满意的结果所发生的概率，L(UO)表示糟糕的结果会产生的破坏性的程度。Boehm思想的核心是10大风险因素列表。针对每个风险因素，都给出了一系列的风险管理策略。在实际操作时，Boehm以10大风险列表为依据，总结当前项目具体的风险因素，评估后进行计划和实施，在下一次定期召开的会议上再对这10大风险因素的解决情况进行总结，产生新的10大风险因素表，依此类推。

　　2.2 SEI的CRM(Continuous Risk Management)模型

　　SEI CRM模型的风险管理原则是：不断地评估可能造成恶劣后果的因素；决定最迫切需要处理的风险；实现控制风险的策略；评测并确保风险策略实施的有效性。CRM模型要求在项目生命期的所有阶段都关注风险识别和管理，它将风险管理划分为五个步骤：风险识别、分析、计划、跟踪、控制。

　　2.3 SERIM(Software Engineering Risk Model)模型

　　SERIM从技术和商业两个角度对软件风险管理进行剖析，考虑的问题涉及开销、进度、技术性能等。它还提供了一些指标和模型来估量和预测风险，由于这些数据来源于大量的实际经验，因此具有很强的说服力。

　　结束语

　　软件项目管理从某种意义上讲，就是风险管理。我们尽量去定义明确不变的需求，以便进行计划并高效管理，但商业环境总是快速变化的，甚至是无序的变化。所以，软件企业在进行项目管理的过程中，必须采用适合自己的风险管理方法进行风险管理，以确保软件项目在规定的预算和期限内完成项目。

一个奇怪但可能有用的缓存

终于有了间茅草棚 — Fri, 06 Jul 2007 07:49:00 GMT

我常用的buffer有std::vector的动态连续缓存和char buf[]的静态缓存。
char buf[]不能够自动增长；std::vector不方便前向读取、不能直接写缓存。这里是一个即连续、又能够自适应，而且可以直接操作缓存的buffer，缺点是使用麻烦。

/**
 * 以下代码由张家旺编写完成于2007-7-5，借用请保留该声明。
 */
#ifndef __BUFFER__
#define __BUFFER__
#include < cassert >
#include < cstring >
namespace useful
{

 class buffer
 {
 public:
  buffer( size_t size );
  ~buffer( void );
  const void *buf_data( void ) const;
  size_t data_size( void ) const;
  void data_dec( size_t size );
  void *buf_empty( void );
  size_t empty_size( void ) const;
  void data_inc( size_t size );
  size_t waste_size( void ) const;
  void data_recycle( size_t size );
  void data_push( const void *data,size_t size );
  void arrange( void );
  void reserve( size_t size );
 private:
  buffer( const buffer &rhs );
  buffer &operator = ( const buffer &rhs );
  char *m_buf;
  size_t m_off,m_use,m_empty;
 };
 inline buffer::buffer( size_t size ) :
  m_buf( new char[size] ),m_off( 0 ),m_use( 0 ),m_empty( size )
 {
  assert( size > 0 );
 }
 inline buffer::~buffer( void )
 {
  delete[] m_buf;
 }
 inline const void *buffer::buf_data( void ) const
 {
  return m_buf + m_off;
 }
 inline size_t buffer::data_size( void ) const
 {
  return m_use;
 }
 inline void buffer::data_dec( size_t size )
 {
  assert( size < = data_size() );
  m_off += size,m_use -= size;
 }
 inline void *buffer::buf_empty( void )
 {
  return m_buf + m_off + m_use;
 }
 inline size_t buffer::empty_size( void ) const
 {
  return m_empty;
 }
 inline void buffer::data_inc( size_t size )
 {
  assert( size < = empty_size() );
  m_use += size,m_empty -= size;
 }
 inline size_t buffer::waste_size( void ) const
 {
  return m_off;
 }
 inline void buffer::data_recycle( size_t size )
 {
  assert( size < = waste_size() );
  m_off -= size,m_use += size;
 }
 inline void buffer::data_push( const void *data,size_t size )
 {
  size_t len = empty_size();
  if( size < = len )
  {
   memcpy( buf_empty(),data,size ); data_inc( size );
   return;
  }
  len += waste_size();
  if( size < = len )
  {
   arrange(); memcpy( buf_empty(),data,size ); data_inc( size );
   return;
  }
  const size_t use = size + data_size();
  len = ( len + data_size() ) < < 1;
  while( use > len ) len = len < < 1;
  char *buf = new char[len];
  memcpy( buf,buf_data(),data_size() );
  memcpy( buf+data_size(),data,size );
  delete[] m_buf; m_buf = buf;
  m_off = 0,m_use = use,m_empty = len - use;
 }
 inline void buffer::arrange( void )
 {
  assert( waste_size() > 0 );
  memmove( m_buf,buf_data(),data_size() );
  m_empty += m_off,m_off = 0;
 }
 inline void buffer::reserve( size_t size )
 {
  size_t now = m_use + m_empty + m_off;
  if( size < = now ) return;
  char *buf = new char[size];
  memcpy( buf,buf_data(),data_size() );
  delete[] m_buf; m_buf = buf;
  m_off = 0,m_empty = size - data_size();
 }

};
#endif /// __BUFFER__

简单内存对象池

终于有了间茅草棚 — Thu, 29 Mar 2007 06:03:00 GMT

很久没有写blog了，一直很懒惰。这几天写了个内存对象池，用于对需要频繁的分配、释放做优化。
在windows和linux下分别试验，结果linux下只有6倍的提升（原因是linux系统内核对小对象本身就有内存对象池优化）。
测试中还发现原来stlPort的vector居然和标准有所出入，msvc8的stl倒是表现很准确（不过，ms的basic_ifstream似乎有问题）。

/**
 * 以下代码由张家旺编写完成于2007-3-29，借用请保留该声明。
 */
#ifdef _MSC_VER
# pragma once
#endif
#ifndef __MEM_POOL__
#define __MEM_POOL__
namespace useful
{

template < class T > class allocator
{
public:
 typedef size_t     size_type;
 typedef ptrdiff_t    difference_type;
 typedef T      *pointer;
 typedef const T     *const_pointer;
 typedef T      &reference;
 typedef const T     &const_reference;
 typedef T      value_type;
 pointer address( reference x ) const
 {
  return &x;
 }
 const_pointer address( const_reference x ) const
 {
  return &x;
 }
 void construct( pointer p,const T &t )
 {
  new ( p ) T( t );
 }
 void destroy( pointer p )
 {
  p->~T();
 }

 pointer allocate( size_type n = 1,void *hint = 0 );
 void deallocate( pointer p,size_type n = 1 );
 pointer constructEx( const T &t )
 {
  pointer p = allocate( 1,0 );
  new ( p ) T( t );
  return p;
 }
 void destroyEx( pointer p )
 {
  p->~T();
  deallocate( p,1 );
 }
};
template < class T1, class T2 >
 bool operator==( const allocator< T1 > &a1,const allocator< T2 > &a2 ) throw()
{
 return &a1 == &a2;
}
template < class T1, class T2 >
 bool operator!=( const allocator< T1 > &a1,const allocator< T2 > &a2 ) throw()
{
 return &a1 != &a2;
}
template < class T,int N >
class allocator1 : public allocator< T >
{
public:
 typedef size_t     size_type;
 typedef ptrdiff_t    difference_type;
 typedef T      *pointer;
 typedef const T     *const_pointer;
 typedef T      &reference;
 typedef const T     &const_reference;
 typedef T      value_type;
 template < class U > struct rebind { typedef allocator1< U,N > other; };
 allocator1( void ) throw();
 template < class U > allocator1( const allocator1< U,N > & ) throw() {}
 ~allocator1( void ) throw();
 size_type max_size( void ) const throw();
 pointer allocate( size_type n = 1,void *hint = 0 );
 void deallocate( pointer p,size_type n = 1 );
private:
 struct mem_node {
  char buf[sizeof(T)*N];
  void *use[N];
  size_type reuse;
  struct mem_node *next;
 } m_head;
 static void initialize( struct mem_node &node );
 static void finalize( struct mem_node &node );
 static void *allocate( struct mem_node &node );
 static bool deallocate( void *p,struct mem_node &node );
};
template < class T,int N >
void allocator1< T,N >::initialize( struct mem_node &node )
{
 for( size_type i = 0; i < N; ++i )
  node.use[i] = node.buf+sizeof(T)*i;
 node.reuse = N;
 node.next = 0;
}
template < class T,int N >
allocator1< T,N >::allocator1( void ) throw()
{
 initialize( m_head );
}
template < class T,int N >
void allocator1< T,N >::finalize( struct mem_node &node )
{
 if( node.next != 0 ) finalize( *node.next );
 delete &node;
}
template < class T,int N >
allocator1< T,N >::~allocator1( void ) throw()
{
 if( m_head.next != 0 ) finalize( *m_head.next );
}
template < class T,int N >
typename allocator1< T,N >::size_type
allocator1< T,N >::max_size( void ) const throw()
{
 const struct mem_node *node = &m_head;
 while( node != 0 && node->reuse < = 0 ) node = node->next;
 return node == 0 ? N : node->reuse;
}
template < class T,int N >
void *allocator1< T,N >::allocate( struct mem_node &node )
{
 return node.reuse > 0 ? node.use[--node.reuse] : 0;
}
template < class T,int N >
typename allocator1< T,N >::pointer
allocator1< T,N >::allocate( size_type,void *hint )
{
 void *p;
 struct mem_node *node = &m_head;
 while( (p=allocate(*node)) == 0 )
 {
  if( node->next != 0 ) node = node->next;
  else
  {
   struct mem_node *node_ = new struct mem_node;
   initialize( *node_ );
   node = node->next = node_;
  }
 }
 return static_cast< pointer >( p );
}
template < class T,int N >
bool allocator1< T,N >::deallocate( void *p,struct mem_node &node )
{
 if( p < node.buf || p >= node.use ) return false;
 node.use[node.reuse++] = p;
 return true;
}
template < class T,int N >
void allocator1< T,N >::deallocate( pointer p,size_type n )
{
 struct mem_node *node = &m_head,*prev;
 while( !deallocate(p,*node) ) prev = node,node = node->next;
 if( node != &m_head && node->reuse >= N )
 {
  prev->next = node->next;
  delete node;
 }
}
template < class T >
class allocator2 : public allocator< T >
{
public:
 typedef size_t     size_type;
 typedef ptrdiff_t    difference_type;
 typedef T      *pointer;
 typedef const T     *const_pointer;
 typedef T      &reference;
 typedef const T     &const_reference;
 typedef T      value_type;
 template < class U > struct rebind { typedef allocator2< U > other; };
 allocator2( size_type num = 1024 ) throw();
 template < class U > allocator2( const allocator2< U > & ) throw() {}
 ~allocator2( void ) throw();
 size_type max_size( void ) const throw();
 pointer allocate( size_type n = 1,void *hint = 0 );
 void deallocate( pointer p,size_type n = 1 );
private:
 struct mem_node {
  void *buf;
  void **use;
  size_type num,reuse;
  struct mem_node *next;
 } *m_head;
 static mem_node &allocate0( size_type num );
 static void deallocate0( mem_node &node );
 static void finalize( mem_node &node );
 static void *allocate0( mem_node &node );
 static bool deallocate0( void *p,mem_node &node );
};
template < class T >
typename allocator2< T >::mem_node &allocator2< T >::allocate0( size_type num )
{
 char *p = new char[sizeof(mem_node)+num*(sizeof(T)+sizeof(void *))];
 mem_node &node = *reinterpret_cast< mem_node * >( p );
 node.buf = ( p += sizeof(mem_node) );
 node.use = reinterpret_cast< void ** >( p + sizeof(T)*num );
 for( size_type i = 0; i < num; ++i )
  node.use[i] = p + sizeof(T)*i;
 node.reuse = node.num = num;
 node.next = 0;
 return node;
}
template < class T >
void allocator2< T >::deallocate0( mem_node &node )
{
 char *p = reinterpret_cast< char * >( &node );
 delete[] p;
}
template < class T >
allocator2< T >::allocator2( size_type num ) throw() : m_head( &allocate0(num) )
{
}
template < class T >
void allocator2< T >::finalize( mem_node &node )
{
 if( node.next != 0 ) finalize( *node.next );
 deallocate0( node );
}
template < class T >
allocator2< T >::~allocator2( void ) throw()
{
 finalize( *m_head );
}
template < class T >
typename allocator2< T >::size_type
allocator2< T >::max_size( void ) const throw()
{
 const mem_node *node = m_head,*prev;
 while( node != 0 && node->reuse < = 0 ) prev = node,node = node->next;
 return node == 0 ? prev.num : node->reuse;
}
template < class T >
void *allocator2< T >::allocate0( mem_node &node )
{
 return node.reuse > 0 ? node.use[--node.reuse] : 0;
}
template < class T >
typename allocator2< T >::pointer
allocator2< T >::allocate( size_type,void *hint )
{
 void *p;
 mem_node *node = m_head;
 while( (p=allocate0(*node)) == 0 )
 {
  if( node->next != 0 ) node = node->next;
  else node = node->next = &allocate0( node->num );
 }
 return static_cast< pointer >( p );
}
template < class T >
bool allocator2< T >::deallocate0( void *p,mem_node &node )
{
 if( p < node.buf || p >= node.use ) return false;
 node.use[node.reuse++] = p;
 return true;
}
template < class T >
void allocator2< T >::deallocate( pointer p,size_type n )
{
 mem_node *node = m_head,*prev;
 while( !deallocate0(p,*node) ) prev = node,node = node->next;
 if( node != m_head && node->reuse >= node->num )
 {
  prev->next = node->next;
  deallocate0( *node );
 }
}

};
#endif //__MEM_POOL__

一个简单的makefile

终于有了间茅草棚 — Mon, 22 Jan 2007 09:38:00 GMT

NAME := main.exe
CXX := g++
LINK := g++

CXXFLAGS += -I$(STL)/stlport
CXXFLAGS += -I$(ACE)
CXXFLAGS += -I../include
CXXFLAGS += -g -w
CXXFLAGS += -DNET_BASE_API=
#CXXFLAGS += -c

LINKOPTS += -L$(STL)/lib
LINKOPTS += -L$(ACE)/lib
#LINKOPTS += -o

SRC := *.cpp
OBJS := $(SRC:*.cpp=*.o)

$(NAME) : $(OBJS)
$(LINK) -o $(NAME) $(OBJS) $(LINKOPTS)

$(OBJS) : $(SRC)
$(CXX) -c $(SRC) $(CXXFLAGS)

.PHONY : clean
clean :
-del /f $(NAME) $(OBJS)

.PHONY : install
install :
@echo "no installation made"

.PHONY : echo
echo :
@echo $(CXX) -c $(SRC) $(CXXFLAGS)
@echo $(LINK) -o $(NAME) $(OBJS) $(LINKOPTS)

自己的lzw实现

终于有了间茅草棚 — Fri, 22 Sep 2006 01:51:00 GMT

好久没有写点内容了。
一是工作忙；另一个也是才疏学浅没什么独到见解可写；而且，我写blog往往都是想用于记录。

自己写的lzw算法的实现，vc8.0 和 g++ 3.2.3 编译通过（看看一堆的typedef typename就是为了g++）。
由于lzw是流式无损压缩算法，本想用于网络，实际测试下来压缩效果并不是很理想（可能和我所取的编码位数有关）。
现将代码贴于下面，有需要的朋友可以直接使用；如有性能、内存方面的优化实现，如果方便，希望能和我分享。

#ifndef __COMPRESS__
#define __COMPRESS__
//#pragma once
#include <cassert>
#include <vector>
#include <map>
#include <algorithm>

namespace coder
{

 template< unsigned bit >
 struct size_max
 {
  enum
  {
   VALUE = 2*size_max< bit-1 >::VALUE,
  };
 };
 template< >
 struct size_max< 1 >
 {
  enum
  {
   VALUE = 2,
  };
 };

 template< class source_t,class code_t,int bit = sizeof(code_t)*8 >
 struct encode_eq
 {
  ///最大静态编码
  static const code_t max_code = size_max< sizeof(source_t)*8 >::VALUE;
  const code_t operator()( const source_t &data ) const
  {
   return ( max_code - 1 ) & data;
  }
 };
 template< class source_t,class code_t,int bit = sizeof(code_t)*8 >
 struct decode_eq
 {
  ///最大静态编码
  static const code_t max_code = size_max< sizeof(source_t)*8 >::VALUE;
  const source_t operator()( const code_t &data ) const
  {
   assert( data < max_code );
   return static_cast< source_t >( data );
  }
 };

 ///源码、码字、源码位长、编码位长、静态编码器
 template< class source_t,
  class code_t,int bit = sizeof(code_t)*8,
  class encoder = encode_eq< source_t,code_t,bit > >
 struct compressor
 {
  ///源码流数据
  typedef std::vector< source_t >    datas_t;
  ///码字流数据
  typedef std::vector< code_t >    codes_t;
 private:
  ///动态码字
  struct codeEx_t
  {
   code_t prefix,suffix;
   bool operator < ( const codeEx_t &code ) const
   {
    if( prefix == code.prefix )
    {
     return suffix < code.suffix;
    }
    else
    {
     return prefix < code.prefix;
    }
   }
  };
  ///动态码表
  typedef std::map< const codeEx_t,code_t > codesEx_t;
  ///最多扩展编码数
  enum
  {
   num_codeEx = size_max< bit >::VALUE - encoder::max_code,
  };
 public:
  compressor( encoder en = encoder() ) : m_encode( en ) {}
  void operator()( const datas_t &in,codes_t &out )
  {
   assert( !in.empty() );
   codeEx_t code;
   code.prefix = m_encode( in.front() );
   typedef typename datas_t::const_iterator iter_t;
   for( iter_t i = in.begin() + 1; i != in.end(); ++i )
   {
    code.suffix = m_encode( *i );
    typedef typename codesEx_t::iterator iter2_t;
    iter2_t j = m_cat.find( code );
    if( j != m_cat.end() )
    {
     const code_t c = j->second;
     code.prefix = j->second;
    }
    else
    {
     if( m_cat.size() < num_codeEx )
     {
      const code_t c = m_cat.size() + encoder::max_code;
      typedef typename codesEx_t::value_type value_t;
      m_cat.insert( m_cat.end(),value_t(code,c) );
     }
     out.push_back( code.prefix );
     code.prefix = code.suffix;
    }
   }
   out.push_back( code.prefix );
  }
 private:
  ///基础编码器
  encoder m_encode;
  ///动态编码表
  codesEx_t m_cat;
 };

 ///源码、码字、每码位长、静态解码器
 template< class source_t,
  class code_t,int bit = sizeof(code_t)*8,
  class decoder = decode_eq< source_t,code_t,bit > >
 struct decompressor {
  ///源码流数据
  typedef std::vector< source_t >    datas_t;
  ///码字流数据
  typedef std::vector< code_t >    codes_t;
 private:
  ///动态码字
  struct codeEx_t
  {
   code_t prefix,suffix;
   bool operator < ( const codeEx_t &code ) const
   {
    if( prefix == code.prefix )
    {
     return suffix < code.suffix;
    }
    else
    {
     return prefix < code.prefix;
    }
   }
  };
  ///动态码表
  typedef std::map< const codeEx_t,code_t > codesEx_t;
  typedef std::map< code_t,const codeEx_t > decode_t;
  ///最多扩展编码数
  enum
  {
   num_codeEx = size_max< bit >::VALUE - decoder::max_code,
  };
 public:
  decompressor( decoder de = decoder() ) : m_decode( de ) {}
  void operator()( const codes_t &in,datas_t &out )
  {
   assert( !in.empty() );
   code_t code0 = in.front();
   out.push_back( m_decode(code0) );
   typedef typename codes_t::const_iterator iter_t;
   for( iter_t i = in.begin() + 1; i != in.end(); ++i )
   {
    code0 = decode( code0,*i,out );
   }
  }
 private:
  bool valid( code_t code ) const
  {
   if( code >= decoder::max_code )
   {
    typedef typename decode_t::const_iterator iter_t;
    iter_t i = m_dec.find( code );
    return i != m_dec.end();
   }
   else
   {
    return true;
   }
  }
  const code_t suffix( code_t code ) const
  {
   assert( valid(code) );
   if( code >= decoder::max_code )
   {
    const codeEx_t &c = m_dec.find( code )->second;
    assert(  c.suffix < decoder::max_code );
    return c.suffix;
   }
   else
   {
    return code;
   }
  }
  const code_t prefix( code_t code ) const
  {
   assert( valid(code) );
   while( code >= decoder::max_code )
   {
    const codeEx_t &c = m_dec.find( code )->second;
    code = c.prefix;
    assert( valid(code) );
   }
   return code;
  }
  const code_t encode( code_t prefix,code_t suffix )
  {
   const codeEx_t k1 = { prefix,suffix };
   typedef typename codesEx_t::iterator iter_t;
   iter_t i = m_cat.find( k1 );
   if( i != m_cat.end() )
   {
    return i->second;
   }
   else
   {
    if( m_cat.size() < num_codeEx )
    {
     const code_t k2 = m_cat.size() + decoder::max_code;
     typedef typename codesEx_t::value_type value1_t;
     m_cat.insert( m_cat.end(),value1_t(k1,k2) );
     typedef typename decode_t::value_type value2_t;
     m_dec.insert( m_dec.end(),value2_t(k2,k1) );
    }
    return suffix;
   }
  }
  const code_t decode( code_t previous,code_t code,datas_t &out )
  {
   assert( valid(previous) );
   if( code >= decoder::max_code )
   {
    typedef typename decode_t::iterator iter_t;
    const iter_t i = m_dec.find( code );
    if( i != m_dec.end() )
    {
     const codeEx_t &c = i->second;
     decode( previous,c.prefix,out );
     out.push_back( m_decode(c.suffix) );
    }
    else
    {
     assert( code == m_cat.size() + decoder::max_code );
     const code_t tmp = encode( previous,prefix(previous) );
     assert( tmp == prefix(previous) );
     decode( previous,code,out );
    }
   }
   else
   {
    encode( previous,code );
    out.push_back( m_decode(code) );
   }
   return code;
  }
  ///基础解码器
  decoder m_decode;
  ///解码动态表
  decode_t m_dec;
  ///动态编码表
  codesEx_t m_cat;
 };

};

#endif //__COMPRESS__

最基本的3D数学知识

终于有了间茅草棚 — Wed, 07 Jun 2006 14:44:00 GMT

一个多月前就打算写点3D基本数学的记录，可惜太懒惰，一直没有写。

1.矩阵：
 a₁ * x + b₁ * y = c₁;
 a₂ * x + b₂ * y = c2;
 | a₁ b₁ |    | x |    | c₁ |
 | a₂ b₂ |    | y |    | c₂ |
2.点积：
 解析几何    V . W = |V|*|W|*cosQ
 线性代数    V . W = v₁w₁ + v₂w₂ + v₃w₃
3.叉积：
 解析几何    V x W = |V|*|W|*sinQ*n
 线性代数    V x W = (v₂w₃-v₃w₂)i + (v₃w₁-v₁w₃)j + (v₁w₂-v₂w₁)k
4.直线：
 斜率—截距  y = m x + b
 点—斜率    y - y₀ = m ( x - x₀ )
 一般式      a x + b y + c = 0
 参数化      P_(x,y,z) = P₀ + V . t
 显示形式    ( x - x₀ ) / a = ( y - y₀ ) / b = ( z - z₀ ) / c
5.平面：
 点—法线式  a ( x - x₀ ) + b ( y - y₀ ) + c ( z - z₀ ) = 0
 一般形式    a x + b y + c z + d = 0
6.球：
 ( x - x0 )² + ( y - y0 )² + ( z - z0 )² = r²
7.椭球：
 ( x - x0 )² / a² + ( y - y0 )² / b² + ( z - z0 )² / c² = r²

软件工程思想（六）——测试和维护

终于有了间茅草棚 — Tue, 11 Apr 2006 08:14:00 GMT

    林锐《软件工程思想》中，自己深有感触的一些言语摘录。有些可能是反面，有些是正面。

    测试的目的是为了发现尽可能多的缺陷，并期望通过改错来把缺陷统统消灭，以期提高软件的质量。

    测试只能证明缺陷存在，而不能证明缺陷不存在。

    “彻底地测试”只是一种理想

    软件的高质量是设计出来的，而不是靠测试修补出来的。

    α测试不能依赖于开发人员或者测试小组中的任意一方，必须是双方共同参与。

    “白盒测试”必须由开发者自己执行，“黑盒测试”必须由独立的测试人员执行。

    越早改正错误，付出的代价就越低。

    一般认为，如果用户不翻阅手册就能使用软件，那么表明这个软件具有较好的易用性。

    程序出了错误一定要改错，但是“编写优质无错”的程序才是根本的解决之道。

    良好的编程风格意味着良好的可理解性，可以降低维护的代价。

    如果测试与改错工作做得好，后期的维护代价就能降低。反之维护代价就升高。

    再生工程并不见得一定比维护的代价要高，但再生工程在将来获取的利益却要比通过维护得到的多。

    预防性维护是“吃小亏占大便宜”的事。

    如果希望软件系统能活下，必须要对它进行维护。如果希望软件系统有效益，则必须设法降低维护的代价。

软件工程思想（五）——设计编码

终于有了间茅草棚 — Tue, 11 Apr 2006 05:38:00 GMT

    林锐《软件工程思想》中，自己深有感触的一些言语摘录。有些可能是反面，有些是正面。

    良好的体系结构是普遍适用的，它可以高效地处理多种多样的个体需求。

    如果当需求发生变化时，程序员不得不去修改软件的体系结构，那么这个软件的系统设计是失败的。

    上层子系统可以使用下层子系统的功能，而下层子系统不能够使用上层子系统的功能。

    在相邻层之间定义清晰的接口。

    应该让模块仅仅公开必须要让外界知道的内容，而隐藏其它一切内容。

    内聚和耦合是密切相关的，与其它模块存在强耦合的模块通常意味着弱内聚，而强内聚的模块通常意味着与其它模块之间存在弱耦合。

    如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，坚决避免使用内容耦合。

    高效率的程序永远不会过时。

    设计高效率的程序是基于良好的数据结构与算法，而不是基于编程小技巧。

    只有通过预先分析问题来确定必须达到的性能目标，才有希望挑选出正确的数据结构。

    使用简单的设计就能够达到性能目标时，选用复杂的数据结构也是没有道理的。

    我们必须先了解应用的需求，再寻找或设计与实际应用相匹配的数据结构。

    仅靠程序员主观想象设计而成的界面往往得不到大众用户的认可。

    不要片面追求外观漂亮而导致失真或华而不实。

    所有真正杰出的设计一旦被设计好，看起来都是那么的简单和显而易见。但是在获得杰出设计的过程中，需要付出令人难以置信的努力。

    设计孤立的类是比较容易的，难的是正确设计基类及其派生类。

    如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能。

    若在逻辑上B是A的“一种”（a kind of ），则允许B继承A的功能。

    若在逻辑上A是B的“一部分”（a part of），则不允许B继承A的功能，而是要用A和其它东西组合出B。

    没有人强迫你采用何种命名法，但有一点应该做到：自己的程序命名必须一致。

    非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。

    一旦确定了的假定，就要使用断言对假定进行检查。

    一般教科书都鼓励程序员们进行防错性的程序设计，但要记住这种编程风格会隐瞒错误。

    不要编写集多种功能于一身的函数，在函数的返回值中，不要将正常值和错误标志混在一起。

    无论什么时候，都不要觉得自己的编程水平天下第一，看到别人好的技术和风格，要虚心学习。

    如果把系统分析和系统设计比作“战略决策”，那么编程充其量只是“战术”。

软件工程思想（四）——可行性和需求

终于有了间茅草棚 — Fri, 17 Mar 2006 10:00:00 GMT

    林锐《软件工程思想》中，自己深有感触的一些言语摘录。有些可能是反面，有些是正面。

    可行性分析是要决定“做还是不做”。

    需求分析是要决定“做什么，不做什么”。

    即使可行性分析是客观的、科学的，但决策仍有可能是错误的。

    如果在项目做了一大半时需求发生了变化，那将使项目陷入困境。

    当你没碰到一个挑刺的人而感觉这产品好得会让你发大财时，就要做好会破产的心理准备。

    在统计软件总的开发时间时，不能漏掉用于维护的时间。

    软件维护是非常拖后腿的事，它能把前期拿到的利润慢慢地消耗光。

    如果软件的质量不好，将会导致维护的代价很高，企图通过偷工减料而提高生产率，是得不偿失的事。

    技术可行性分析可以简单地表述为：做得了吗？做得好吗？做得快吗？

    社会环境的可行性至少包括两种因素：市场与政策。

    “人分四类——人物，人才，人手，人渣。”

    打破水缸的小孩子很多，但并不见得就会有司马光的业绩。

    如果不允许一个男人在工作时仰天大笑，这样的地方不去也罢。

    我曾得到很多炫目的荣誉，但学生时代的荣誉只是一种鼓励，并不是对我才能和事业的确认。

    只有在具备极大的市场需求、极优秀的知识产品、业界杰出人物的条件下，才可能使一个公司的股值远远高于其“原始投资 + 经营利润”。

    有几种原因使需求分析变得困难：
        （1）客户说不清楚需求；
        （2）需求自身经常变动；
        （3）分析人员或客户理解有误。

    分析人员可以引导客户，先阐述常规的需求，再由客户否定不需要的，最终确定客户真正的需求。

    最怕的就是“不懂装懂”或者“半懂充内行”的客户，他们会提出不切实际的需求。

    据历史记载，没有一个软件的需求改动少于三次。唯一只改动需求两次的客户是个死人。这个可怜的家伙还是在运送第三次需求的路上被车子撞死的。[Cline 1995]

    尽可能地分析清楚哪些是稳定的需求，哪些是易变的需求。

    在合同中一定要说清楚“做什么”和“不做什么”。

    分析人员写好需求说明书后，要请客户方的各个代表验证。如果问题很复杂，双方都不太明白，就有必要请开发人员快速构造软件的原型，双方再次论证需求说明书是否正确。

    需求分析应该先了解宏观的问题，再了解细节的问题。

    在写需求说明书时还应该注意两个问题：
        （1）最好为每个需求注释“为什么”，这样可让程序员了解需求的本质，以便选用最合适的技术来实现此需求。
        （2）需求说明不可有二义性，更不能前后相矛盾。如果有二义性或前后相矛盾，则要重新分析此需求。

    经常分析优秀的和蹩脚的同类软件，看到了优点就尽量吸取，看到了缺点就引以为戒。

    前人既然付了学费，后人就不要拒绝坐享其成。

软件工程思想（三）——计划与质量

终于有了间茅草棚 — Fri, 10 Mar 2006 10:20:00 GMT

    林锐《软件工程思想》中，自己深有感触的一些言语摘录。有些可能是反面，有些是正面。
        ——这一节，和作者有些有分歧的地方。比如：可能着重点不同，或者策略不同。做为整个摘录的子部分，也摘录一些。

    软件的项目计划重在“准确”而非“快速”。

    程序员必须了解软件质量的方方面面。

    在做软件的项目计划时，应屏弃一切浮夸作风。

    人们在陷入项目不能自拨之前总难以准确地估计项目的规模与难度。

    进度表要经过开发小组的讨论，在得到大部数人的支持后才能实施。

    进度安排并不见得一定要符合逻辑顺序。应尽可能地先做技术难度高的事，后做难度低的事。

    进度表中必须留有缓冲时间，并将缓冲时间用到不确定的事情上。

    Microsoft公司的一些开发小组甚至制定了“50% 缓冲规则”[Cusumano 1996]。

    对许多项目经理而言，容忍进度表中存在缓冲时间，不啻为观念上的一个飞跃。

    不要觉得修改进度表很困难很麻烦，不修改才会产生真真的麻烦。

    如果每个人的质量目标是0.95，那么十个人的累积质量不会超过0.19。如果每个人的质量目标是0.9分，那么十个人的累积质量不会超过0.03。

    好规范必须是本企业有能力执行的，一个普通企业照搬一流企业的规范未必行得通。

    国内很多软件公司根本没有条件去执行业界推荐的软件工程规范。

    如果软件系统臃肿不堪，它迟早会出问题。

    虚假的质量检查还不如不检查。

    软件的项目计划和质量管理都不是用来喊叫的口号。

    不要指望在项目陷入困境后靠增加人手来解救。

    软件的高质量主要是设计出来的，不是“管”出来的，更不能依赖质量检查。

    程序员要充分了解软件的质量因素，只有提高设计水平，才能开发出高质量的软件。

基础知识杂记

终于有了间茅草棚 — Fri, 10 Mar 2006 02:42:00 GMT

不借助编译器，说出下面程序的输出。

程序片断一： 
#include <iostream>
class base
{
public:
    void fun( double value )
    {
        std::cout << value << std::endl;
    }
};
class derive : public base
{
public:
    void fun( int value )
    {
        std::cout << value << std::endl;
    }
};
int main( int argc,char *argv[] )
{
    derive d;
    d.fun( 1 );
    d.fun( 1.5 );
    return 0;
}

程序片断二：
#include <iostream>
class base
{
public:
    virtual void fun( void )
    {
        std::cout << "In base" << std::endl;
    }
};
class derive : public base
{
public:
    virtual void fun( void )
    {
        std::cout << "In derive" << std::endl;
    }
};
int main( int argc,char *argv[] )
{
    base *pBase = new derive;
    pBase->fun();
    base &rBase = *pBase;
    rBase.fun();
    return 0;
}

软件工程思想（二）——程序员和管理

终于有了间茅草棚 — Wed, 08 Mar 2006 08:39:00 GMT

    林锐《软件工程思想》中，自己深有感触的一些言语摘录。有些可能是反面，有些是正面。

    要让软件项目失败很容易，只要符合下列条件之一即可：
        （1）项目经理对软件一无所知。
        （2）技术负责人对编程不感兴趣。
        （3）真真编写代码的程序员是临时雇用的。
    如果上述三个条件同时具备，就请放心失败好了。

    真正的程序员都有如下秉性：
        一、诚实
        二、简单——实用主义
        三、爱憎分明
        四、工作单调但不乏味

    不诚实的人，他肯定不想做、也做不好程序员。

    有一名市场营销员和一名程序员都在新闻发布会上发言，将一项新技术的消息公布于众。
    市场营销员说：“这项技术比电话、晶体管和原子弹三项发明加起来对世界文明的影响都要大。”
    程序员说：“这项技术在有限的领域内，在有限的程度上，解决了一些技术性的问题。”

    本来几句话、几行程序就能说明白的事，非得要抬高到理论创新的程度，写成玄乎的文章去评教授或者弄个博士学位。所幸在第一线工作的程序员大多是实干的。

    在一个管理混乱的软件公司里，如果某个程序员能大喊大叫并且干劲十足，那他就能成为一名程序经理。

    好的程序经理应该具备以下几个条件：
        一、技术水平是程序员队伍中的最高级别
        二、能做最多且最难的工作
        三、有人格魅力

    一个有活力的软件公司的各级经理都不会这样感叹，“因为我啥也不会干，所以只好当领导。”

    最怕的是“虚心接受，坚决不做”，或者仅是做个样子。

    新中国历来喜欢与可怜的印度相比较来展现丰富多彩的优越性，可是软件产业没法与人家比。

    软件人员在遭受项目失败并开始反省时，不要只是就事论事地仅把眼光锁在特定的项目上，吃一堑应该长好几个智才对。

    我并不是太爱虚荣的人，知道这次失败是我的毛病积累到一定水准忍不住喷发出来的结果。我绝不能以年纪尚轻不太懂市场与管理为理由轻率地敷衍过去。

    上天不可能赋于一个人太多的优点，以致于他没有表示谦虚的余地。

    程序员不该因为幼稚而显得单纯，应该是成熟了才变得单纯，才配得上这个充满活力的职业。

    软件人员勤奋学习和工作，不该只图将来能做成几件事情的快意，而应力求事业长盛不衰，才能推动整个民族软件产业持久稳健地发展。

软件工程思想（一）——观念和现状

终于有了间茅草棚 — Wed, 08 Mar 2006 08:34:00 GMT

    林锐《软件工程思想》中，自己深有感触的一些言语摘录。有些可能是反面，有些是正面。

    不知是不会摘录，还是太多一致，以至于要copy于下的内容太多。也就只能分几篇blog了。

    从短期效益看，追求高质量会延长软件开发时间并且增大费用，似乎降低了生产率。从长期效益看，高质量将保证软件开发的全过程更加规范流畅，大大降低了软件的维护代价，实质上是提高了生产率，同时可获得很好的信誉。

    质量直接体现在软件的每段程序中，高质量自然是开发人员的技术追求，也是职业道德的要求。

    高质量对所有的用户都有价值，而高生产率只对开发方有意义。

    如果一开始就追求高生产率，容易使人急功近利，留下隐患。

    线性模型太理想化，太单纯，已不再适合现代的软件开发模式，几乎被业界抛弃。偶而被人提起，都属于被贬对象，未被留一丝惋惜。

    勤劳并且聪明的人们应该把大部分的时间用在小比例的创新工作上，而把小部分的时间用在大比例的成熟工作中，这样才能把工作做得又快又好。

    我们拥有最好的开发工具、最好的计算机，一定能做出优秀的软件。

    如果我们落后于计划，可以增加更多的程序员来解决。

    能解决问题的都是好方法或是好语言。

    程序设计是自由与快乐的事情，不要发誓忠于某某主义而自寻烦恼。

    一个局部的优点对整个系统而言是微不足道的，而一个错误则可能是致命的。

    微软的一些开发小组将错误分成四个等级 [Cusumano 1996]:
        一级严重：错误导致软件崩溃。
        二级严重：错误导致一个特性不能运行并且没有替代方案。
        三级严重：错误导致一个特性不能运行但有替代方案。
        四级严重：错误是表面化的或是微小的。

    所有的错误都是严重的，不存在微不足道的错误。