昨天一天的时间，和父亲在旧院里安装了两截水管。
安装水管的工序大致为， 刨开地层土，找到水管主线，然后切开，焊接PE三通，及铺设相关的PE软管、水表等。
刨开地层土为体力活，而焊接三通等为技术活。当然我在其中主要承担了刨开地层土的工作。
我和父亲艰难的用铁锹刨开地表，以寻找水管主线。在坚硬的地表向下，埋设了一层厚厚的碳渣来减轻胡同里雨时的泥泞。这也给刨土增加了很多的难度，老父亲虽然年迈，但是似乎比我刨的熟练，速度比我更快。但我的铁锹在用力时就会稍微弯曲变形，力被减弱，一会儿，额头上便冒出了细细的汗珠。
父亲对我说：你用的那把铁锹是铁板的，而我用的这把铁锹则是钢板的。并且你的那把锹鼻处已经有裂缝，所以会变形弯曲，无法用力。
当我们找到主水管，并且清理用以为焊接容身的方坑时，父亲在一旁休息，我顺手提过父亲用的那把铁锹进行清理。我感觉父亲的那把铁锹非常顺手，硬度很大，几乎不用太大的力锹印便陷入泥土，在一撬的同时稳稳地端出一锹土来。当换了一把铁锹的时候，我才发现，工作进行的如此快速，如此有效率。
当方坑被清理完之后，我们开始了三通的焊接工作，焊接工具是一个称之为“热熔器”的设备，非常简单易用，我们第一次用，很快便掌握了其用法。
三通和PE管分别被套在热熔器上面，一会儿时间，拔出，快速将三通和PE管套接在一块，两者完美的融合，形成一个整体，我再一次赞叹一个合适的工具竟会如此提高我们的工作效率。
接下来开始焊接PE管的时候，我们又遇到了一些困难，是因为我们采用钢锯条来切割PE管，这样由于操作不熟练和不专业，每每导致PE管的横切面毛毛糙糙的，并且带有明显的斜茬，这对焊接后的效果产生一定的影响，一位围观的二叔对我们说：我家有专业的切割工具，剪PE管或PPR管的专业切割剪刀。二叔拿来后，做了一个简单的示范，将PE管放在剪刀口上面，一下一下握剪刀柄，一会的功夫便切割完毕，接过一看，横切面光滑如新，并且非常的整齐，没有一点斜茬的存在。
一天的工作结束了，我们如愿完成了前院和后院水管的安装工作。在傍晚的薄暮里，我慨叹时光的短暂，更加认同于好的工具使我们的工作时间缩短，才使我们用一天的时间完成这项工作。
如同采用合适的或专业的工具完成我们的工作一样，我们在管理中，也应当借助专业的人士来完成我们的目标。在完成目标的过程中，人其实也是工具，在遇到不合适、不顺手、不专业的工具时，你最好换掉他，因为他有可能使我们的工作时间无限的延长到又一个明天。
宝宝1.4岁，路走的不扎实，通常都由她奶奶来带，爷爷次之，妈妈又次之，其中我带孩子时间是最少的。
宝宝刚学会走路时，虽然我还孩子的时间最少，但在我手里宝宝摔倒的次数最多，因此遭到了严厉的批评。
我承认我和他们一样用心来爱宝宝，宝宝的喜乐和哭闹深深地系着我的喜怒和哀乐。但宝宝摔倒的事实如此，我不得而知原因何在。
宝宝奶奶一语道破其中的“玄机”，曰：只因你把宝宝当成大孩子来看待。 一语道过之后，我忽然明朗了。
是的，我始终认为宝宝已经会走，因此应该给她更大的空间，放手她去探索去磨炼。 只因为我的放手，她才一次次在不断地尝试中摔倒。
我应当手不离其左右，配合着她，保护着她，她才能够在摔倒时有支撑或依靠，至少不会造成身体上的伤害。
那么在公司的人员管理中，新人又何尝不是刚学走路的孩童，需要我们管理者无微不至的照顾和指导，在他们不断尝试、不断探索和磨炼的过程中，我们不能等待着他们跌倒后进行自我总结教训，也不能任凭在他们跌倒后自顾着心疼，更不能在他们跌倒后声色俱厉的批评他们做事的方式和方法，因为他们还是个孩童。而管理者，是他们的第一任老师，需要手不离其左右，配合他，保护他，指导他，直到他由走而跑，健步飞。直到那时，才能放手。
本文为大家介绍软件设计中的一些原则，都是经过长期经验总结出来的知识，每一个程序员都应该了解，相信对大家在进行软件设计的过程中会有很大帮助。
Don’t Repeat Yourself (DRY)
DRY 是一个最简单的法则，也是最容易被理解的。但它也可能是最难被应用的（因为要做到这样，我们需要在泛型设计上做相当的努力，这并不是一件容易的事）。它意味着，当我们在两个或多个地方的时候发现一些相似的代码的时候，我们需要把他们的共性抽象出来形一个唯一的新方法，并且改变现有的地方的代码让他们以一些合适的参数调用这个新的方法。
参考：
http://en.wikipedia.org/wiki/KISS_principle
Program to an interface, not an implementation
这是设计模式中最根本的哲学，注重接口，而不是实现，依赖接口，而不是实现。接口是抽象是稳定的，实现则是多种多样的。以后面我们会面向对象的SOLID原则中会提到我们的依赖倒置原则，就是这个原则的的另一种样子。还有一条原则叫 Composition over inheritance（喜欢组合而不是继承），这两条是那23个经典设计模式中的设计原则。
Command-Query Separation (CQS) – 命令-查询分离原则
查询：当一个方法返回一个值来回应一个问题的时候，它就具有查询的性质；
命令：当一个方法要改变对象的状态的时候，它就具有命令的性质；
通常，一个方法可能是纯的Command模式或者是纯的Query模式，或者是两者的混合体。在设计接口时，如果可能，应该尽量使接口单一化，保证方法的行为严格的是命令或者是查询，这样查询方法不会改变对象的状态，没有副作用，而会改变对象的状态的方法不可能有返回值。也就是说：如果我们要问一个问题，那么就不应该影响到它的答案。实际应用，要视具体情况而定，语义的清晰性和使用的简单性之间需要权衡。将Command和Query功能合并入一个方法，方便了客户的使用，但是，降低了清晰性，而且，可能不便于基于断言的程序设计并且需要一个变量来保存查询结果。
在系统设计中，很多系统也是以这样原则设计的，查询的功能和命令功能的系统分离，这样有则于系统性能，也有利于系统的安全性。
参考：
http://en.wikipedia.org/wiki/Command-query_separation
You Ain’t Gonna Need It (YAGNI)
这个原则简而言之为——只考虑和设计必须的功能，避免过度设计。只实现目前需要的功能，在以后您需要更多功能时，可以再进行添加。
如无必要，勿增复杂性。
软件开发先是一场沟通博弈。
以前本站有一篇关于
过度重构的文章，这个示例就是这个原则的反例。而，WebSphere的设计者就
表示过他过度设计了这个产品。我们的程序员或是架构师在设计系统的时候，会考虑很多扩展性的东西，导致在架构与设计方面使用了大量折衷，最后导致项目失败。这是个令人感到讽刺的教训，因为本来希望尽可能延长项目的生命周期，结果反而缩短了生命周期。
参考：
http://en.wikipedia.org/wiki/You_Ain%27t_Gonna_Need_It
Law of Demeter – 迪米特法则
迪米特法则(Law of Demeter)，又称“最少知识原则”（Principle of Least Knowledge），其来源于1987年荷兰大学的一个叫做Demeter的项目。Craig Larman把Law of Demeter又称作“不要和陌生人说话”。在《程序员修炼之道》中讲LoD的那一章叫作“解耦合与迪米特法则”。关于迪米特法则有一些很形象的比喻：
如果你想让你的狗跑的话，你会对狗狗说还是对四条狗腿说？
如果你去店里买东西，你会把钱交给店员，还是会把钱包交给店员让他自己拿？
和狗的四肢说话？让店员自己从钱包里拿钱？这听起来有点荒唐，不过在我们的代码里这几乎是见怪不怪的事情了。
对于LoD，正式的表述如下：
在《Clean Code》一书中，有一段Apache framework中的一段违反了LoD的代码：
final String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath();
这么长的一串对其它对象的细节，以及细节的细节，细节的细节的细节……的调用，增加了耦合，使得代码结构复杂、僵化，难以扩展和维护。
在《重构》一书中的代码的环味道中有一种叫做“Feature Envy”(依恋情结），形象的描述了一种违反了LoC的情况。Feature Envy就是说一个对象对其它对象的内容更有兴趣，也就是说老是羡慕别的对象的成员、结构或者功能，大老远的调用人家的东西。这样的结构显然是不合理的。我们的程序应该写得比较“害羞”。不能像前面例子中的那个不把自己当外人的店员一样，拿过客人的钱包自己把钱拿出来。“害羞”的程序只和自己最近的朋友交谈。这种情况下应该调整程序的结构，让那个对象自己拥有它羡慕的feature，或者使用合理的设计模式（例如Facade和Mediator）。
参考：
http://en.wikipedia.org/wiki/Principle_of_Least_Knowledge
面向对象的S.O.L.I.D 原则
一般来说这是面向对象的五大设计原则，但是，我觉得这些原则可适用于所有的软件开发。
Single Responsibility Principle (SRP) – 职责单一原则
关于单一职责原则，其核心的思想是：
一个类，只做一件事，并把这件事做好，其只有一个引起它变化的原因。单一职责原则可以看作是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而极大的损伤其内聚性和耦合度。单一职责，通常意味着单一的功能，因此不要为一个模块实现过多的功能点，以保证实体只有一个引起它变化的原因。
Unix/Linux是这一原则的完美体现者。各个程序都独立负责一个单一的事。
Windows是这一原则的反面示例。几乎所有的程序都交织耦合在一起。
Open/Closed Principle (OCP) – 开闭原则
关于开发封闭原则，其核心的思想是：模块是可扩展的，而不可修改的。也就是说，
对扩展是开放的，而对修改是封闭的。
对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。
对于面向对象来说，需要你依赖抽象，而不是实现，23个经典设计模式中的“策略模式”就是这个实现。对于非面向对象编程，一些API需要你传入一个你可以扩展的函数，比如我们的C 语言的qsort()允许你提供一个“比较器”，STL中的容器类的内存分配，ACE中的多线程的各种锁。对于软件方面，浏览器的各种插件属于这个原则的实践。
Liskov substitution principle (LSP) – 里氏代换原则
软件工程大师Robert C. Martin把里氏代换原则最终简化为一句话：“Subtypes must be substitutable for their base types”。也就是，子类必须能够替换成它们的基类。即：子类应该可以替换任何基类能够出现的地方，并且经过替换以后，代码还能正常工作。另外，不应该在代码中出现if/else之类对子类类型进行判断的条件。里氏替换原则LSP是使代码符合开闭原则的一个重要保证。正是由于子类型的可替换性才使得父类型的模块在无需修改的情况下就可以扩展。
这么说来，似乎有点教条化，我非常建议大家看看这个原则个两个最经典的案例——“正方形不是长方形”和“鸵鸟不是鸟”。通过这两个案例，你会明白《墨子 小取》中说的 ——“娣，美人也，爱娣，非爱美人也….盗，人也；恶盗，非恶人也。”——妹妹虽然是美人，但喜欢妹妹并不代表喜欢美人。盗贼是人，但讨厌盗贼也并不代表就讨厌人类。
这个原则让你考虑的不是语义上对象的间的关系，而是实际需求的环境。
在很多情况下，在设计初期我们类之间的关系不是很明确，LSP则给了我们一个判断和设计类之间关系的基准：需不需要继承，以及怎样设计继承关系。
Interface Segregation Principle (ISP) – 接口隔离原则
接口隔离原则意思是把功能实现在接口中，而不是类中，使用多个专门的接口比使用单一的总接口要好。
举个例子，我们对电脑有不同的使用方式，比如：写作，通讯，看电影，打游戏，上网，编程，计算，数据等，如果我们把这些功能都声明在电脑的抽类里面，那么，我们的上网本，PC机，服务器，笔记本的实现类都要实现所有的这些接口，这就显得太复杂了。所以，我们可以把其这些功能接口隔离开来，比如：工作学习接口，编程开发接口，上网娱乐接口，计算和数据服务接口，这样，我们的不同功能的电脑就可以有所选择地继承这些接口。
这个原则可以提升我们“搭积木式”的软件开发。对于设计来说，Java中的各种Event Listener和Adapter，对于软件开发来说，不同的用户权限有不同的功能，不同的版本有不同的功能，都是这个原则的应用。
Dependency Inversion Principle (DIP) – 依赖倒置原则
高层模块不应该依赖于低层模块的实现，而是依赖于高层抽象。
举个例子，墙面的开关不应该依赖于电灯的开关实现，而是应该依赖于一个抽象的开关的标准接口，这样，当我们扩展程序的时候，我们的开关同样可以控制其它不同的灯，甚至不同的电器。也就是说，电灯和其它电器继承并实现我们的标准开关接口，而我们的开关产商就可不需要关于其要控制什么样的设备，只需要关心那个标准的开关标准。这就是依赖倒置原则。
这就好像浏览器并不依赖于后面的web服务器，其只依赖于HTTP协议。这个原则实在是太重要了，社会的分工化，标准化都是这个设计原则的体现。
参考：
http://en.wikipedia.org/wiki/Solid_(object-oriented_design)
Common Closure Principle（CCP）– 共同封闭原则
一个包中所有的类应该对同一种类型的变化关闭。一个变化影响一个包，便影响了包中所有的类。一个更简短的说法是：一起修改的类，应该组合在一起（同一个包里）。如果必须修改应用程序里的代码，我们希望所有的修改都发生在一个包里（修改关闭），而不是遍布在很多包里。CCP原则就是把因为某个同样的原因而需要修改的所有类组合进一个包里。如果2个类从物理上或者从概念上联系得非常紧密，它们通常一起发生改变，那么它们应该属于同一个包。
CCP延伸了开闭原则（OCP）的“关闭”概念，当因为某个原因需要修改时，把需要修改的范围限制在一个最小范围内的包里。
参考：
http://c2.com/cgi/wiki?CommonClosurePrinciple
Common Reuse Principle (CRP) – 共同重用原则
包的所有类被一起重用。如果你重用了其中的一个类，就重用全部。换个说法是，没有被一起重用的类不应该被组合在一起。CRP原则帮助我们决定哪些类应该被放到同一个包里。依赖一个包就是依赖这个包所包含的一切。当一个包发生了改变，并发布新的版本，使用这个包的所有用户都必须在新的包环境下验证他们的工作，即使被他们使用的部分没有发生任何改变。因为如果包中包含有未被使用的类，即使用户不关心该类是否改变，但用户还是不得不升级该包并对原来的功能加以重新测试。
CCP则让系统的维护者受益。CCP让包尽可能大（CCP原则加入功能相关的类），CRP则让包尽可能小（CRP原则剔除不使用的类）。它们的出发点不一样，但不相互冲突。
参考：
http://c2.com/cgi/wiki?CommonReusePrinciple
Hollywood Principle – 好莱坞原则
好莱坞原则就是一句话——“don’t call us, we’ll call you.”。意思是，好莱坞的经纪人们不希望你去联系他们，而是他们会在需要的时候来联系你。也就是说，所有的组件都是被动的，所有的组件初始化和调用都由容器负责。组件处在一个容器当中，由容器负责管理。
简单的来讲，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：
1.不创建对象，而是描述创建对象的方式。
2.在代码中，对象与服务没有直接联系，而是容器负责将这些联系在一起。
控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。
好莱坞原则就是IoC（Inversion of Control）或DI（Dependency Injection ）的基础原则。这个原则很像依赖倒置原则，依赖接口，而不是实例，但是这个原则要解决的是怎么把这个实例传入调用类中？你可能把其声明成成员，你可以通过构造函数，你可以通过函数参数。但是 IoC可以让你通过配置文件，一个由Service Container 读取的配置文件来产生实际配置的类。但是程序也有可能变得不易读了，程序的性能也有可能还会下降。
参考：
[url]http://en.wikipedia.org/wiki/Hollywood_Principle [/url]
[url]http://en.wikipedia.org/wiki/Inversion_of_Control [/url]
High Cohesion & Low/Loose coupling & – 高内聚， 低耦合
这个原则是UNIX操作系统设计的经典原则，把模块间的耦合降到最低，而努力让一个模块做到精益求精。
内聚：一个模块内各个元素彼此结合的紧密程度
耦合：一个软件结构内不同模块之间互连程度的度量
内聚意味着重用和独立，耦合意味着多米诺效应牵一发动全身。
参考：
http://en.wikipedia.org/wiki/Coupling_(computer_science)
[url]http://en.wikipedia.org/wiki/Cohesion_(computer_science) [/url]
Convention over Configuration（CoC）– 惯例优于配置原则
简单点说，就是将一些公认的配置方式和信息作为内部缺省的规则来使用。例如，Hibernate的映射文件，如果约定字段名和类属性一致的话，基本上就可以不要这个配置文件了。你的应用只需要指定不convention的信息即可，从而减少了大量convention而又不得不花时间和精力啰里啰嗦的东东。配置文件很多时候相当的影响开发效率。
Rails 中很少有配置文件（但不是没有，数据库连接就是一个配置文件），Rails 的fans号称期开发效率是 java 开发的 10 倍，估计就是这个原因。Maven也使用了CoC原则，当你执行mvn -compile命令的时候，不需要指源文件放在什么地方，而编译以后的class文件放置在什么地方也没有指定，这就是CoC原则。
参考：
http://en.wikipedia.org/wiki/Convention_over_Configuration
Separation of Concerns (SoC) – 关注点分离
SoC 是计算机科学中最重要的努力目标之一。这个原则，就是在软件开发中，通过各种手段，将问题的各个关注点分开。如果一个问题能分解为独立且较小的问题，就是相对较易解决的。问题太过于复杂，要解决问题需要关注的点太多，而程序员的能力是有限的，不能同时关注于问题的各个方面。正如程序员的记忆力相对于计算机知识来说那么有限一样，程序员解决问题的能力相对于要解决的问题的复杂性也是一样的非常有限。在我们分析问题的时候，如果我们把所有的东西混在一起讨论，那么就只会有一个结果——乱。
我记得在上一家公司有一个项目，讨论就讨论了1年多，项目本来不复杂，但是没有使用SoC，全部的东西混为一谈，再加上一堆程序员注入了各种不同的观点和想法，整个项目一下子就失控了。最后，本来一个1年的项目做了3年。
实现关注点分离的方法主要有两种，一种是标准化，另一种是抽象与包装。标准化就是制定一套标准，让使用者都遵守它，将人们的行为统一起来，这样使用标准的人就不用担心别人会有很多种不同的实现，使自己的程序不能和别人的配合。Java EE就是一个标准的大集合。每个开发者只需要关注于标准本身和他所在做的事情就行了。就像是开发镙丝钉的人只专注于开发镙丝钉就行了，而不用关注镙帽是怎么生产的，反正镙帽和镙丝钉按标来就一定能合得上。不断地把程序的某些部分抽像差包装起来，也是实现关注点分离的好方法。一旦一个函数被抽像出来并实现了，那么使用函数的人就不用关心这个函数是如何实现的，同样的，一旦一个类被抽像并实现了，类的使用者也不用再关注于这个类的内部是如何实现的。诸如组件，分层，面向服务，等等这些概念都是在不同的层次上做抽像和包装，以使得使用者不用关心它的内部实现细节。
说白了还是“高内聚，低耦合”。
参考：
http://sulong.me/archives/99
Design by Contract (DbC) – 契约式设计
DbC的核心思想是对软件系统中的元素之间相互合作以及“责任”与“义务”的比喻。这种比喻从商业活动中“客户”与“供应商”达成“契约”而得来。例如：
供应商必须提供某种产品（责任），并且他有权期望客户已经付款（权利）。
客户必须付款（责任），并且有权得到产品（权利）。
契约双方必须履行那些对所有契约都有效的责任，如法律和规定等。
同样的，如果在程序设计中一个模块提供了某种功能，那么它要：
期望所有调用它的客户模块都保证一定的进入条件：这就是模块的先验条件（客户的义务和供应商的权利，这样它就不用去处理不满足先验条件的情况）。
保证退出时给出特定的属性：这就是模块的后验条件——（供应商的义务，显然也是客户的权利）。
在进入时假定，并在退出时保持一些特定的属性：不变式。
契约就是这些权利和义务的正式形式。我们可以用“三个问题”来总结DbC，并且作为设计者要经常问：
它期望的是什么？
它要保证的是什么？
它要保持的是什么？
根据Bertrand Meyer氏提出的DBC概念的描述，对于类的一个方法，都有一个前提条件以及一个后续条件，前提条件说明方法接受什么样的参数数据等，只有前提条件得到满足时，这个方法才能被调用；同时后续条件用来说明这个方法完成时的状态，如果一个方法的执行会导致这个方法的后续条件不成立，那么这个方法也不应该正常返回。
现在把前提条件以及后续条件应用到继承子类中，子类方法应该满足：
1.前提条件不强于基类．
2.后续条件不弱于基类．
换句话说，通过基类的接口调用一个对象时，用户只知道基类前提条件以及后续条件。因此继承类不得要求用户提供比基类方法要求的更强的前提条件，亦即，继承类方法必须接受任何基类方法能接受的任何条件（参数）。同样，继承类必须顺从基类的所有后续条件，亦即，继承类方法的行为和输出不得违反由基类建立起来的任何约束，不能让用户对继承类方法的输出感到困惑。
这样，我们就有了基于契约的LSP，基于契约的LSP是LSP的一种强化。
参考：
http://en.wikipedia.org/wiki/Design_by_contract
Acyclic Dependencies Principle (ADP) – 无环依赖原则
包之间的依赖结构必须是一个直接的无环图形，也就是说，在依赖结构中不允许出现环（循环依赖）。如果包的依赖形成了环状结构，怎么样打破这种循环依赖呢？有2种方法可以打破这种循环依赖关系：第一种方法是创建新的包，如果A、B、C形成环路依赖，那么把这些共同类抽出来放在一个新的包D里。这样就把C依赖A变成了C依赖D以及A依赖D，从而打破了循环依赖关系。第二种方法是使用DIP（依赖倒置原则）和ISP（接口分隔原则）设计原则。
无环依赖原则（ADP）为我们解决包之间的关系耦合问题。在设计模块时，不能有循环依赖。
参考：
http://c2.com/cgi/wiki?AcyclicDependenciesPrinciple
在使用ExtJs过程中，性能一直是一个比较头疼的问题，从用户的角度来看，就一个字：慢。从技术的角度来说，这个“慢”字可以分为两种，加载“慢”和渲染“慢”。想分辨这两种情况很容易：如果居于网不慢而互联网上慢，说明是加载慢；如果Chrome不慢而IE慢，就是渲染慢。还有另一种情况：越用越慢，这个“慢”通常是内存泄露造成的。
针对以下这三种情况讨论一下解决方案：
1，加载慢
1.1 减少要加载的东西
不要动不动就ext-all.js，extjs是可以定制的，如果你用不到tree，就不要包含这个组件了。ExtJs的官网上有详细的定制方法和工具。
1.2 给出合适的用户提示
把Js后置，然后前面做一个加载的提示。如果像Gmail那样给出进度条，或者像很多网游那样来点图片或者Tips啥的就更好了，说不定用户还会觉得怎么加载这么快，我还没看清楚呢，呵呵。
1.3 用的时候再加载
动态加载，参考使用ExtJs开发MIS系统（2）：Js的动态加载。
1.4 只加载一次
别用iframe了，如果你的静态内容过期做的不好，浏览器会经常再不厌其烦的从服务器下载同样的东西。
1.5 对你的Js添加过期标记
ext-base.js、ext-all.js都可以设置很长的过期时间，甚至永不过期（如果你不换extjs的版本）。这点对所有静态内容都很有用，如何设置过期标记请垂询Google。
2，渲染慢
2.1 少加载少解析、晚加载晚解析
1.1，1.3，1.4都对改善渲染慢的情况有效——加载的少了自然渲染的快了。
2.2 别用iframe
iframe不仅仅可能会使浏览器加载两遍，还一定会使浏览器解析两遍，放弃它吧，真的。
2.3 精心设计你的Js代码
例如缓存getElementByID()的结果、编译查询表达式之类的东西，这个纯看Js功力。
2.4 可能的话，让用户换个浏览器吧
Chrome比IE的Js渲染快是数量级上的差异！构造一个40列，50行的复杂GridPanel试试，你就会深有体会了……对于企业内部的MIS系统，换浏览器还是具有可能性的。
3，内存泄露
Ext性能调优方案
1. 将JS进行合并压缩。
使用yahoo的yui-compress.jar进行压缩JS，去掉过多的空格和注释，并合并，减少IO的支出。
2. 将前后台传输的数据进行GZIP压缩。
大数据量的数据传输，通过GZIP的压缩方案，可以减少到25%，有些数据可能会更多。
3. 对大量的JS分析依赖关系，进行动态加载。
这个是关键，通过分析所有的JS中的依赖关系，减少了JS加载的数量。从很大程度上提高了性能。
4. 另外对部分页面进行缓存，而非真正的关闭。
还有一个外部的因素，由于系统使用的客户机环境上的复杂，我们在多个浏览器上进行了测试，只有IE是最慢的，尤其是IE6，后来发现不是IE6要比IE7慢，是因为发现MS发布了脚本引擎cscript 5.7, 而大部分的ie6系统都装的是5.6, 这个版本上的升级，不仅仅是修改了BUG，在JS的执行速度上也有了较大的提升，于是我们在环境因素上又加上了一条，要求客户安装cscript5.7，也大大的提升了页面的打开时间。
ext-all.js这个文件都有500多k，在页面中直接引用这个js文件是很不现实的，曾经在一个大的项目中使用这个js，则直接导致页面半天出不来的后果。于是自己研究了下，目前通过下面的方法来优化提升Ext Js的性能。
使用JSVM
JSVM (JavaScript Virtual Machine的缩写)，一个JavaScript基础框架，sourceforge开源项目，由万常华（wch3116）于2003年底发起, 目前最新版本是2.05,采用的是 BSD License 授权协议。本身JSVM也提供了JSVM+Ext2的实例，看看就知道怎么在JSVM下加入ext的js库了。
我在项目中是这么用的：
<script type= "text/javascript" src= "/depporject/comjs/jsvm2/jsre.js" classpath= "dom2.gzjs;ext2p.gzjs" modules= "smartloader" ></script>
使用Gzip压缩
gzip压缩后，ext js文件的大小将只有100k左右。
只是对gzip压缩的文件需要提供filter（Java开发），为你的应用提高解压缩功能,filter的写法很简单：
public void doFilter(HttpServletRequest request,
HttpServletResponse response, FilterChain chain)
throws IOException, ServletException 
{
for (Iterator it = headers.entrySet().iterator();it.hasNext();) {
Map.Entry entry = (Map.Entry)it.next();
response.addHeader((String)entry.getKey(),(String)entry.getValue());
}
chain.doFilter(request, response);
}
public void init(FilterConfig config) throws ServletException {
String headersStr = config.getInitParameter( "headers" );
String[] headers = headersStr.split( "," );
for ( int i = 0 ; i < headers.length; i++) {
String[] temp = headers[i].split( "=" );
this .headers.put(temp[ 0 ].trim(), temp[ 1 ].trim());
}
}
}
web.xml配置
< filter >
< filter-name > addHeaderFilter </ filter-name >
< filter-class >org .common.AddHeaderFilter </ filter-class >
< init-param >
< param-name > headers </ param-name >
< param-value > Content-Encoding = gzip </ param-value >
</ init-param >
</ filter >
通过以上两步，整个页面装载速度很快了。大家可以试试。
另外在实际开发中，并不是将ext-all.js全部在jsvm中装载，只是将常用的ext js代码归到一起，由gzip压缩，然后又jsvm装载（即ext2p.js，p代表部分），剩下的ext js代码由jsvm按需装载。
概念解释
在实际的业务中，对于工作流一般是这样定义的：
定义完成某项工作需要多少个环节，每个环节由哪些人处理，完成这项工作的表单。
实际处理的时候，通常由发起人填好表单，然后去找各个环节的负责人签字审批，一直到流程结束。
在JBPM的框架中，用ProcessDefinition来描述某项工作，Activity描述各个定义的环节，Transition描述环节中的路径。
ProcessDefinitionInstance来描述实际执行的工作，可能是继承了ProcessDefinition，但又多出很多属性，如建立时间，发起人等，
Task或Excution来描述实际执行的步骤。
相应地有RespositoryService，ExcutionService，TaskService，来操作ProcessDefinition，Excution，Task，使工作一步步地往定义好的步骤往下走。
Excution表示实际流程中的当前环节，即以前的Token。
编程实务
画好流程图，即定义流程，画好一堆的步骤。
作好每个环节中要展示的JSP页面，并配到流程定义中。
写好每个环节提交后要处理的JAVA代码。
JBPM流程定义
流程定义的中间环节有两种：
一种是流程引擎碰到这种环节，会自动流转到下一环节，如Decision，Java等。
另一种是流程引擎碰到这种环节，会处于等待状态，直到程序下指令如：excuSinal才流转到下一环节，
这里面又分两种：一种是有处理人属性的Task，由处理人决定下一环节的流向，另一种是没设处理人，由程序决定下一环节的走向，如State。
实际流程中可以放变量值，以供整个流程环节存取。
如果流程定义中用了变量或表达式，则其实际值，会取实际流程中放进去的值。
如Task节点：
加一个Task节点时，将assignee设成表达式，这样在生成Task记录时，会读取绑定到流程实例中变量的值，作为assignee的值，
也可以指定一个CLASS，在生成Task记录时，会运行其中的assign方法，读取assignable中的getAssignee()的值，作为Task的分配人。
退回的解决方案
退回就是将此Task退回到上一环节的处理人处。
画图的时候不画退回的路径，但在程序处理中用代码加这一Task指向上一环节的路径，complete(taskId,newTransition)使其回到上一环节，然后再删除这一Transition。
会签的解决方案
会签指的是将同一任务同时分派给多人并行处理。
用For-each和join实现，或动态增加子任务。