diff --git a/blog/en-us/framework/agility.md b/blog/en-us/framework/agility.md
new file mode 100644
index 0000000..0c0b7fb
--- /dev/null
+++ b/blog/en-us/framework/agility.md
@@ -0,0 +1,77 @@
+# 如何理解敏捷开发
+
+## 为什么要敏捷开发
+
+“没有人喜欢敏捷，但我们不得不敏捷。就像没有人喜欢工作，但你必须工作。”这是我经常用来调侃敏捷的一句话。试想一下，拿到一份完整详尽的需求文档，逐个功能Coding，测试部署上线。不需要再次确认需求，不会有人打断思路。没有需求更改，只要自己不犯错，不存在推倒重来这才是大部分开发人员最舒服的工作方式吧，简直太完美了。但它很像瀑布，一点都不敏捷。既然我们喜欢的工作方式是传统的、瀑布的，为什么要敏捷？这还不都是市场环境逼的。今天的市场向我们提出了三个问题：
+
+## 01如何做出真正满足用户需求的产品？
+
+我不确定这世上是否有人可以做到，他所做出的全部决定都是对的。但绝大多数人是无法一次性做出真正满足用户需求的产品的。我们无法预测未来，我们必须通过一次次的测试，去寻找用户需要的产品是什么？想要更快地获得好的产品，必须迅速将产品推向市场，快速试验，避免走弯路。
+
+## 02如何满足不断变化的用户需求？
+
+今天所有的事情的都在快速变化，用户的需求也在变化。毫不夸张地说，我们正在全力开发的一些功能，当它们上线的时候，我们的用户已经不再需要了。我们没有办法让一切不变，我们只能选择去拥抱变化。
+
+## 03如何同时满足不同层次用户的需求？
+
+过去我们的产品会遵循产品生命周期，早期追求新奇的尝鲜者，中期普通大众，后期落后者。今天，产品的生命周期变化非常地快，我们可能会同时面对尝鲜者、普通大众、落后者，不同的用户类型的需求是不一样的，你如何满足他们？我们必须快速响应，没法快速响应，就没法留住用户，没有用户就没有一切。迅速将产品推向市场，拥抱变化、快速响应。今天的市场向所有的从业者提出了一个要求：拥有应对快速变化的需求的软件开发能力。而敏捷就是赋予团队应对快速变化的需求的软件开发能力的方法，而这就是敏捷流行的原因。
+
+## 什么是敏捷开发
+
+敏捷绝非某一种特定的开发方法，它只是一种应对快速变化的需求的一种软件开发能力。敏捷本身只包含了《敏捷软件开发宣言》和《敏捷软件的十二条原则》两份文档。敏捷相信，只要符合这两份文档的开发方法，就能让开发团队拥有应对快速变化需求的能力，这样的开发方法都叫做敏捷开发方法。
+
+## 最流行的敏捷开发方式是什么
+
+敏捷开发的方法有很多：ASD、AUP、DSDM、XP、FDD、Kanban、RAD、Scrum。目前国内最流行的应属Scrum。Scrum本意是指橄榄球运动中的“带球过人”，它可以解决非常复杂的项目，并且能高效并创造性地交付高价值的产品。Scrum包含3个角色、3个工件、5个价值观、5个事件 [详情https://www.scrum.org](https://www.scrum.org/)。相比其他敏捷方法，Scrum既不简单又不复杂。它有完善的指南，你可以按照指南，轻易在团队内推广尝试。但想要实践好Scrum，又需要很好的技巧。这种易上手难精通的方法，特别适合培训机构。所以近几年，关于Scrum的培训机构遍地都是。可以说，在Scrum流行这件事上，这些培训机构做了很大的贡献。
+
+## 如何实施Scrum
+
+在团队中实施敏捷开发是一个很有挑战性的工作，尤其是Scrum这种描述比较详细、有很多规则的方法。
+
+**如果你打算把所有人召集到一起，宣布我们要实施敏捷开发Scrum，然后就照着Scrum的描述开发方法直接实施，那么，你离失败不远了。**想要实施好Scrum，你必须一步步来，一点一点改变团队的习惯，当一项新制度已经变成本能之后，再推行下一项制度。
+
+### >>>>第一步，先把团队的开发任务可视化。
+
+你可以用一块白板，让团队成员把所有的开发任务都用便签写好放上去，也可以找一个专业的看板工具。我推荐日事清，当所有任务都在看板上，尽收眼底，那种感觉还是很棒的。团队中每个人的工作都会被所有人看到，会形成一种无形的监督。
+
+### >>>>第二步，引入站会制度。
+
+当团队所有人的任务都在看板后，这些任务的状态是需要有人更新的。无论是专人更新，还是每个人自己更新，都会出现忘记更新，更新不及时的情况。这时，就可以顺势引入站会制度了。每天上班的时候，或者每天下班的时候，所有人站到一起，花15分钟，说一下自己做了什么，准备做什么，所有人一起把看板更新了。
+
+### >>>>第三步，引入回顾会议
+
+当站会制度成熟后，就可以挑一个版本发布的日子。等版本发布后，把团队成员叫到一起，开一个回顾会。让团队成员对这个版本开发的情况做个总结，同时可以让大家用便签把这个开发版本遇到的问题、不满写下来。针对这些问题不满，大家一起讨论一些改进方案。
+
+### >>>>第四步，引入计划会议
+
+如果再开回顾会的时候，有人提出需求不清，拆解不够细致，工时估算不准之类的问题，那你真是太幸运了。碰到这种情况，你顺势提出这个制度：每个版本开发前，产品经理要和团队人员开个会，一起逐条对需求。产品经理要向团队解释每个需求，并且对团队提出的疑问进行解释和澄清。开发团队要将需求分解成任务，估算工时，最终形成一个开发清单。
+
+### >>>>第五步，引入评审会议
+
+当计划会成功开过几次之后，就可以考虑引入评审会了。你可以在某个重大功能发布的时候，把所有项目相关的人员召集起来，向大家展示团队做了哪些了不起的功能，也可以和大家讨论讨论还可以做哪些优化。
+
+### >>>>第六步，宣布引入Scrum
+
+当整个流程都跑顺以后，就可以在某次全体会议上，提出我们要实施Scrum了。你需要任命PO、SM，对团队培训Scrum知识，讲解Scrum的价值观。
+
+## 实施敏捷开发会面临怎样的挑战
+
+1.团队成员对变化的恐惧
+
+实施Scrum最大的挑战来自内部，来自团队对变化的恐惧。每个团队在运营一段时间后都会形成固有的默契和习惯，引入Scrum必然会打破这种习惯。这会让团队很不舒服，团队也会抵制，甚至是反抗。而且实施敏捷的过程，一定不是一帆风顺的，尤其是实施敏捷的早期阶段，不仅不会对团队产生太大的价值，反而会引起混乱。所以，在实施敏捷的过程中，千万要小心，每次只改变一点点，敏捷地完成敏捷。
+
+2.组织人员的专业化水
+
+平敏捷并不会直接提高团队的专业化水平，反而对团队专业化水平有一定的要求。必要的专业分工、合适的专业能力是必须的。敏捷会让开发整个流程持续运转，当某一个环节专业化能力出现问题的时候，会极大地导致整个流程运转停滞。平时团队中的问题会在敏捷中快速暴露。一旦出现专业水平问题，要及时解决，补充人员，或者帮助其提高能力。即使问题并不严重，也要在最短的时间解决，否则会影响团队对敏捷的信心。
+
+3.产品经理这个组织Bug
+
+国内在实施Scrum的时候经常会碰到的问题就是团队中会有产品经理这个角色。
+
+**一般的处理方法是产品经理当PO**，但PO是需要领导开发团队的。国内的产品经理往往不是技术出身，领导开发团队会出很多问题，所以产品经理并不适合当PO。
+
+**另一种做法是产品经理做利益相关者**，这种做法更不靠谱，利益相关者离团队太远，会出现无法及时响应的问题，时间长了也会导致产品和开发之间关系冷漠，出现隔阂。我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错
+
+我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错
+
+另外腾讯企业微信里[**TAPD**](https://www.tapd.cn)也是不错的
\ No newline at end of file
diff --git a/blog/en-us/framework/fwork.md b/blog/en-us/framework/fwork.md
new file mode 100644
index 0000000..598956f
--- /dev/null
+++ b/blog/en-us/framework/fwork.md
@@ -0,0 +1,143 @@
+# 走向架构师必备的技能
+
+中国有很多年轻人，他们18,9岁或21,2岁，通过自学也写了不少代码，他们有的代码写的很漂亮，一些技术细节相当出众，也很有钻研精神，但是他们被一些错误的认识和观点左右，缺乏对系统，对程序的整体理解能力，这些人，一个网上的朋友说得很好，他们实际fans，压根没有资格称为程序员，但是据我所知，不少小网络公司的Cfans,拿着吓人的工资，做着吓人的项目，项目的结局通常也很吓人。
+
+## 　程序员基本素质：
+
+作一个真正合格的程序员，或者说就是可以真正合格完成一些代码工作的程序员，应该具有的素质。
+
+1. 团队精神和协作能力 
+
+把它作为基本素质，并不是不重要，恰恰相反，这是程序员应该具备的最基本的，也是最重要的安身立命之本。把高水平程序员说成独行侠的都是在呓语，任何个人的力量都是有限的，即便如linus这样的天才，也需要通过组成强大的团队来创造奇迹，那些遍布全球的为linux写核心的高手们，没有协作精神是不可想象的。独行侠可以作一些赚钱的小软件发点小财，但是一旦进入一些大系统的研发团队，进入商业化和产品化的开发任务，缺乏这种素质的人就完全不合格了。
+
+2. 文档习惯 
+
+说高水平程序员从来不写文档的肯定是乳臭未干的毛孩子，良好的文档是正规研发流程中非常重要的环节，作为代码程序员，30％的工作时间写技术文档是很正常的，而作为高级程序员和系统分析员，这个比例还要高很多。缺乏文档，一个软件系统就缺乏生命力，在未来的查错，升级以及模块的复用时就都会遇到极大的麻烦。
+
+3. 规范化，标准化的代码编写习惯
+
+作为一些外国知名软件公司的规矩，代码的变量命名，代码内注释格式，甚至嵌套中行缩进的长度和函数间的空行数字都有明确规定，良好的编写习惯，不但有助于代码的移植和纠错，也有助于不同技术人员之间的协作。
+fans叫嚣高水平程序员写的代码旁人从来看不懂，这种叫嚣只能证明他们自己压根不配自称程序员。代码具有良好的可读性，是程序员基本的素质需求。
+再看看整个linux的搭建，没有规范化和标准化的代码习惯，全球的研发协作是绝对不可想象的。
+
+4. 需求理解能力 
+
+程序员需要理解一个模块的需求，很多小朋友写程序往往只关注一个功能需求，他们把性能指标全部归结到硬件，操作系统和开发环境上，而忽视了本身代码的性能考虑，有人曾经放言说写一个广 告交换程序很简单，这种人从来不知道在百万甚至千万数量级的访问情况下的性能指标是如何实现的，对于这样的程序员，你给他深蓝那套系统，他也做不出太极链的并访能力。性能需求指标中，稳定性，并访支撑能力以及安全性都很重要，作为程序员需要评估该模块在系统运营中所处的环境，将要受到的负荷压力以及各种潜在的危险和恶意攻击的可能性。就这一点，一个成熟的程序员至少需要2到3年的项目研发和跟踪经验才有可能有心得。
+
+5. 复用性，模块化思维能力 
+
+经常可以听到一些程序员有这样的抱怨，写了几年程序，变成了熟练工，每天都是重复写一些没有任何新意的代码，这其实是中国软件人才最大浪费的地方，一些重复性工作变成了熟练程序员的主要工作，而这些，其实是完全可以避免的。
+
+复用性设计，模块化思维就是要程序员在完成任何一个功能模块或函数的时候，要多想一些，不要局限在完成当前任务的简单思路上，想想看该模块是否可以脱离这个系统存在，是否可以通过简单的修改参数的方式在其他系统和应用环境下直接引用，这样就能极大避免重复性的开发工作，如果一个软件研发单位和工作组能够在每一次研发过程中都考虑到这些问题，那么程序员就不会在重复性的工作中耽误太多时间，就会有更多时间和精力投入到创新的代码工作中去。
+
+一些好的程序模块代码，即便是70年代写成的，拿到现在放到一些系统里面作为功能模块都能适合的很好，而现在我看到的是，很多小公司软件一升级或改进就动辄全部代码重写，大部分重复性工作无谓的浪费了时间和精力。
+
+6. 测试习惯 
+
+作为一些商业化正规化的开发而言，专职的测试工程师是不可少的，但是并不是说有了专职的测试工程师程序员就可以不进行自测；软件研发作为一项工程而言，一个很重要的特点就是问题发现的越早，解决的代价就越低，程序员在每段代码，每个子模块完成后进行认真的测试，就可以尽量将一些潜在的问题最早的发现和解决，这样对整体系统建设的效率和可靠性就有了最大的保证。
+
+测试工作实际上需要考虑两方面，一方面是正常调用的测试，也就是看程序是否能在正常调用下完成基本功能，这是最基本的测试职责，可惜在很多公司这成了唯一的测试任务，实际上还差的远那；第二方面就是异常调用的测试，比如高压力负荷下的稳定性测试，用户潜在的异常输入情况下的测试，整体系统局部故障情况下该模块受影响状况的测试，频发的异常请求阻塞资源时的模块稳定测试等等。当然并不是程序员要对自己的每段代码都需要进行这种完整测试，但是程序员必须清醒认识自己的代码任务在整体项目中的地位和各种性能需求，有针对性的进行相关测试并尽早发现和解决问题，当然这需要上面提到需求理解能力。
+
+7. 学习和总结的能力 
+
+程序员是人才很容易被淘汰，很容易落伍的职业，因为一种技术可能仅仅在三两年内具有领先性，程序员如果想安身立命，就必须不断跟进新的技术，学习新的技能。
+
+善于学习，对于任何职业而言，都是前进所必需的动力，对于程序员，这种要求就更加高了。但是学习也要找对目标，一些小coding有些codingTO就是这样的coding上只是一些Cfans们，他们也津津乐道于他们的学习能力，一会学会了asp，一会儿学会了php，一会儿学会了jsp，他们把这个作为炫耀的资本，盲目的追逐一些肤浅的，表面的东西和名词，做网络程序不懂通讯传输协议，做应用程序不懂中断向量处理，这样的技术人员，不管掌握了多少所谓的新语言，永远不会有质的提高。
+
+善于总结，也是学习能力的一种体现，每次完 成一个研发任务，完成一段代码，都应当有目的的跟踪该程序的应用状况和用户反馈，随时总结，找到自己的不足，这样逐步提高，一个程序员才可能成长起来。
+
+一个不具备成长性的程序员，即便眼前看是个高手，建议也不要选用，因为他落伍的时候马上就到了。具备以上全部素质的人，应当说是够格的程序员了，请注意以上的各种素质都不是由IQ决定的，也不是大学某些课本里可以学习到的，需要的仅仅是程序员对自己工作的认识，是一种意识上的问题。 
+
+
+## 高级程序员
+
+那么作为高级程序员，以至于系统分析员，也就是对于一个程序项目的设计者而言，除了应该具备上述全部素质之外，还需要具备以下素质：
+
+1. 需求分析能力 
+
+对于程序员而言，理解需求就可以完成合格的代码，但是对于研发项目的组织和管理者，他们不但要理解客户需求，更多时候还要自行制定一些需求，为什么这么说呢？
+
+一般而言，进行研发任务，也许是客户提出需求，也许是市场和营销部门提出的需求，这时候对于研发部门，他们看到的不是一个完整的需求，通常而言，该需求仅仅是一些功能上的要求，或者更正规些，可能获得一个完整的用户视图；但是这都不够，因为客户由于非技术因素多一些，他们可能很难提出完整和清晰，或者说专业性的性能需求，但是对于项目组织者和规划者，他必须能够清醒认识到这些需求的存在并在完成 需求分析报告的时候适当的提出，同时要完整和清晰的体现在设计说明书里面，以便于程序员编码时不会失去这些准则。
+
+程序设计者必须正确理解用户需求所处的环境，并针对性做出需求的分析，举例而言，同样一个软件通过ASP租用方式发布和通过License方式发布，性能需求可能就是有区别的，前者强调的是更好的支撑能力和稳定性，而后者则可能更强调在各种平台下的普适性和安装使用的简捷性。
+
+2. 项目设计方法和流程处理能力 
+
+程序设计者必须能够掌握不少于两到三种的项目设计方法（比如自顶至下的设计方法，比如快速原型法等等），并能够根据项目需求和资源搭配来选择合适的设计方法进行项 目的整体设计。设计方法上选择不当，就会耽误研发周期，浪费研发资源，甚至影响研发效果。
+
+一个程序设计者还需要把很多功夫用在流程图的设计和处理上，他需要做数据流图以确立数据词典；他需要加工逻辑流图以形成整体的系统处理流程。一个流程有问题的系统，就算代码多漂亮，每个模块多精致，也不会成为一个好的系统。当然，做好流程分析并选择好项目设计方法，都需要在需求分析能力上具有足够的把握。
+
+3. 复用设计和模块化分解能力 
+
+这个似乎又是老调重谈，前面基本素质上不是已经说明了这个问题吗？作为一个从事模块任务的程序员，他需要对他所面对的特定功能模块的 复用性进行考虑，而作为一个系统分析人员，他要面对的问题复杂的多，需要对整体系统按照一种模块化的分析能力分解为很多可复用的功能模块和函数，并针对每一模块形成一个独立的设计需求。举个例子，好比是汽车生产，最早每辆汽车都是独立安装的，每个部件都是量身定做的，但是后来不一样了，机器化大生产了，一个汽车厂开始通过流水线来生产汽车，独立部件开始具有一定的复用性，在后来标准化成为大趋势，不同型号，品牌甚至不同厂商的汽车部件也可以进行方便的换装和升级，这时候，汽车生产的效率达到最大化。软件工程也是同样的道理，一个成熟的软件行业，在一些相关项目和系统中，不同的部件是可以随意换装的，比如微软的许多桌面软件，在很多操作模块（如打开文件，保存文件等等）都是复用的同一套功能模块，而这些接口又通过一些类库提供给了桌面应用程序开发者方便挂接，这就是复用化的模块设计明显的一个佐证。
+
+将一个大型的，错综复杂的应用系统分解成一些相对独立的，具有高度复用性的，并能仅仅依靠几个参数完成数据联系的模块组合，是作为高级程序员和系统分析员一项最重要的工作，合适的项目设计方法，清晰的流程图，是实现这一目标的重要保证。
+
+4. 整体项目评估能力 
+
+作为系统设计人员，必须能够从全局出发，对项目又整体的清醒认识，比如公司的资源配置是否合理和到位，比如工程进度安排是否能最大化体现效率又不至于无法按期完成。评估项 目整体和各个模块的工作量，评估项目所需的资源，评估项目可能遇到的困难，都需要大量的经验积累，换言之，这是一种不断总结的累计才能达到的境界。在西方一些软件系统设计的带头人都是很年长的，比如4，50岁，甚至更老，他们在编码方面已经远远不如年轻人那样活络，但是就项目评估而言，他们几十年的经验积累就是最重要和宝贵的财富。中国缺这么一代程序员，主要还不是缺那种年纪的程序员，而是那种年纪的程序员基本上都是研究单位作出来的，都不是从专业的产品化软件研发作出来的，他们没有能积累那种产品化研发的经验，这也是没有办法的事情。
+
+5. 团队组织管理能力 
+
+完成一个项目工程，需要团队的齐心协力，作为项目设计者或研发的主管人，就应当有能力最大化发挥团队的整体力量，技术管理由于其专业性质，不大同于一般的人事管理，因为这里面设计了一些技术性的指标和因素。
+
+首先是工作的量化，没有量化就很难做到合适的绩效考核，而程序量化又不是简单的代码行数可以计算的，因此要求技术管理人员需要能真正评估一个模块的复杂性和工作量。
+
+其次是对团队协作模式的调整，一般而言，程序开发的协作通常分为小组进行，小组有主程序员方式的，也有民主方式的，根据程序员之间的能力水平差距，以及根据项目研发的需求，选择合适的组队方式，并能将责权和成员的工作任务紧密结合，这样才能最大发挥组队的效率。
+
+一个代码水平高的人，未必能成为一个合格的项目研发主管，这方面的能力欠缺往往是容易被忽视的。
+
+综上可以看到，作为一个主管研发的负责人，一个项目设计者，所需要具备的素质和能力并不是程序代码编写的能力，当然一般情况下，一个程序员通过不断的总结提高达到了这种素质的时候，他所具有的代码编写能力也已经相当不简单了，但是请注意这里面的因果关系，一个高水平的项目设计者通常已经是代码编写相当优秀的人了，但是并不是一个代码相当优秀的程序员就可以胜任项目设计的工作，这里面存在的也不是智商和课本的问题，还是在于一个程序员在积累经验，逐步提升的时候没有意识到应当思考哪方面的东西，没有有意识的就项目的组织和复用设计进行揣摩，没有经常性的文档习惯和总结习惯， 不改变这些，我们的合格的项目设计者还是非常欠缺。
+
+另外，为防止有无聊的人和我较真，补充一点，本文针对目标是作商业化的软件项目和工程，那些科研机构的编程高手，比如算法高手，比如图象处理高手，他们的工作是研究课题而非直接完成商业软件（当然最终间接成为商业产品，比如微软研究院在作的研究课题），因此他们强调的素质可能是另外的东西，这些人（专家），并不能说是程序员，不能用程序员的标准去衡量。
+
+最后补充一点东西，一个软件项目研发的设计流程是怎样的呢？以通常标准的设计方法为例，（不过笔者喜欢快速原型法）。
+
+* 第一个步骤是市场调研，技术和市场要结合才能体现最大价值。 
+
+* 第二个步骤是需求分析，这个阶段需要出三样东西，用户视图，数据词典和用户操作手册。用户视图是该软件用户（包括终端用户和管理用户）所能看到的页面样式，这里面包含了很多操作方面的流程和条件。数据词典是指明数据逻辑关系并加以整理的东东，完成了数据词典，数据库的设计就完成了一半多。用户操作手册是指明了操作流程的说明书。
+
+注意，用户操作流程和用户视图是由需求决定的，因此应该在软件设计之前完成，完成这些，就为程序研发提供了约束和准绳，很遗憾太多公司都不是这样做的，因果颠倒，顺序不分，开发工作和实际需求往往因此 产生隔阂脱节的现象。
+
+需求分析，除了以上工作，笔者以为作为项目设计者应当完整的做出项目的性能需求说明书，因为往往性能需求只有懂技术的人才可能理解，这就需要技术专家和需求方（客户或公司市场部门）能够有真正的沟通和了解。
+
+* 第三个步骤是概要设计，将系统功能模块初步划分，并给出合理的研发流程和资源要求。作为快速原型设计方法，完成概要设计就可以进入编码阶段了，通常采用这种方法是因为涉及的研发任务属于新领域，技术主管人员一上来无法给出明确的详细设计说明书，但是并不是说详细设计说明书不重要，事实上快速原型法在完成原型代码后，根据评测结果和经验教训的总结，还要重新进行详细设计的步骤。 
+
+* 第四个步骤是详细设计，这是考验技术专家设计思维的重 要关卡，详细设计说明书应当把具体的模块以最‘干净’的方式(黑箱结构）提供给编码者，使得系统整体模块化达到最大；一份好的详细设计说明书，可以使编码的复杂性减低到最低，实际上，严格的讲详细设计说明书应当把每个函数的每个参数的定义都精精细细的提供出来，从需求分析到概要设计到完成详细设计说明书，一个软件项目就应当说完成了一半了。换言之，一个大型软件系统在完成了一半的时候，其实还没有开始一行代码工作。那些把作软件的程序员简单理解为写代码的，就从根子上犯了错误了。 
+
+* 第五个步骤是编码，在规范化的研发流程中，编码工作在整个项目流程里最多不会超过1/2，通常在1/3的时间，所谓磨刀不误砍柴功，设计过程完成的好，编码效率就会极大提高，编码时不同模块之间的进度协调和协作是最需要小心的，也许一个小模块的问题就可能影响了整体进度，让很多程序员因此被迫停下工作等待，这种问题在很多研发过程中都出现过。编码时的相互沟通和应急的解决手段都是相当重要的，对于程序员而言，bug永远存在，你必须永远面对这个问题，大名鼎鼎的微软，可曾有连续三个月不发补丁的时候吗？从来没有！
+
+*  第六个步骤是测试 
+
+测试有很多种：按照测试执行方，可以分为内部测试和外部测试；按照测试范围，可以分为模块测试和整体联调；按照测试条 件，可以分为正常操作情况测试和异常情况测试；按照测试的输入范围，可以分为全覆盖测试和抽样测试。以上都很好理解，不再解释。
+
+总之，测试同样是项目研发中一个相当重要的步骤，对于一个大型软件，3个月到1年的外部测试都是正常的，因为永远都会又不可预料的问题存在。
+
+完成测试后，完成验收并完成最后的一些帮助文档，整体项目才算告一段落，当然日后少不了升级，修补等等工作，只要不是想通过一锤子买卖骗钱，就要不停的跟踪软件的运营状况并持续修补升级，知道这个软件被彻底淘汰为止。
+
+写这些步骤算不上卖弄什么，因为实话讲我手边是一本《软件工程》，在大学里这是计算机专业的必修课程，但是我知道很多程序员似乎从来都只是热衷于什么《30天精通VC》之类的，他们有些和我一样游击队出身，没有正规学过这个专业，还有一些则早就在混够学分后就把这些真正有用的东西还给了老师。
+
+fans乱嚷嚷，混淆视听，实际上真正的技术专家很少在网上乱发帖子的，如笔者这样不知天高地厚的，其实实在是算不上什么高手，只不过看不惯这种对技术，对程序员的误解和胡说，只好挺身而出，做拨乱反正之言，也希望那些还fans们能认真想想，走到正途上，毕竟那些聪明的头脑还远远没有发挥应有的价值。沉迷于一些错误人士的coding
+
+从程序员升级到工程师大多数象我这样对软件有浓厚兴趣的人，毕业后义无反顾地走进了企业，开始了程序员的生涯。那时，我们迷恋“大全”、“秘籍”一类的书籍，心中只有代码。当我看到一行行枯燥的代码变成了能够打电话的设备，变成了屏幕上漂亮的表格，变成了动听的音乐，成就感油然而生。我觉得自己也是一个出色的程序员了。在用户的机房中苦熬三昼夜解决软件的bug，也成了一种可以夸耀的资历。五年前的某一天，我把曾经让我兴奋自豪的大量代码和少得可怜的文档移交之后，来到了华为。这里有更多的年轻人，我如鱼得水，可以充分发挥自己的想象力。依然是代码，依然是匆匆地在纸上记下稍纵即逝的灵感（我们把它称作文档），依然是无休止地和bug作斗争。当有一天，一个新来 的同事拿着署着我的大名的文档，小心翼翼地来问我时，我发现自己好象有点不认识它了。我心里有点沮丧，再看看代码，发现文档上记录的一些灵感已面目全非。我当时不知道那位新来的同事感受如何，但我从那时起，好象意识到什么。现在来看，那时的很多事情都是事倍功半。
+
+去年年底，我学习印度从事项目开发，学习印度的软件开发管理方法。一种久违的冲动在心底升起。我在学习过程中和印度的工程师交流过，他们言谈中透着自信。他们给我讲解正在做的软件的测试环境，给我看他们写的单元测试文档。当我看到一个软件模块的单元测试用例有三百多页时，我觉得心里很是沉重。当我第三次踏上这片土地时，我又见到了熟悉的人们，明亮的眼睛，温和的笑容，随意的穿着，风驰电掣的摩托，还有大学校园中穿着拖鞋，手抱书本的年轻人。
+
+我也见到了我的项目经理，一个个子较高，瘦瘦的年轻人，据说刚从美国回来，已工作了五、六年。我听了心里很高兴，这回要一招一式地学两手。需求分析的时间是一个月，项目经理和我们（实际上代表客户 ）讨论了proposal中的内容，确定每一项都是需要的。然后他把模块大致划分了一下，开始进入计划中的学习阶段。每个人在学习阶段要写出功能描述的胶片，给其他人讲解，不知不觉中，项目组的所有人对项目有了整体的了解。
+
+
+　他还安排了一些培训，如他们公司的软件开发模型、项目组中各角色的定义，以后及时的培训不断，只要项目组中有需求，他总是把qa或相关的人请来，培训很专业。需求分析完成后提交了一份四十多页的文档，当我看到这份英文文档中我写的部分整整齐齐地列在其中时，我的感觉很复杂，有些喜悦，但更多的是苦涩，我以前怎么就从来没有这样做过需求分析呢。
+
+在我写文档的过程中，qa给我们培训过srs的写作模板，后来我还是不放心，让他们一个有经验的工程师写了一段，我们再琢磨着照着写。这份srs虽然是多个人合写，但风格一致，内容详实。更为可贵的是，一直到最后，这份需求分析的内容都没有改过，以至于我们没有机会走一下他们的需求更改流程。
+
+需求分析是项目的第一阶段，第二阶段的开发时间要根据需求分析的结果来确定。当对方的首席技术官（相当于我们业务部的总体组长）来和我们讨论计划时，他们已列出了对每个 模块的代码行数的预测，可能存在的风险。根据他们公司的生产率－－300行/人月，他得出了项目第二阶段需要多少周。
+
+我们当时就提出了异议：1）公司对该项目需求很急；2）每月300行是否太少；3）我们还有下载的源代码参考。他解释说，300行/人月是使得项目能达到他们质量标准的经验数据，考虑到有源代码参考，生产率最多不能超过350行/人月。
+
+　当他问我们公司的生产率时，我脑袋里转了三个圈，没敢多说，大概六、七百行吧。他沉默了一会儿，然后坚定地说，我们这个计划是建立在确保质量的基础上的，我想你们到印度来开发软件，首先看中的应该是我们印度公司的质量保证。我知道你们不缺乏软件开发人员，你们为什么不选择下载的软件呢。几句话说到了我的痛处，现在国内的弟兄们还在为使用下载软件移植的产品四处奔波呢！
+
+　随后的开发活动有条不紊，我们老老实实地跟着做。系统测试计划、用例，概要设计，集成测试计划、用例，详细设计，单元测试计划、用例，编码，单元测试，集成测试，系统测试。一个完整的v模型开发过程，其中每个过程都有review。当我们对一些设计的方法不太明白时，项目经理给我们发来了相关的资料，我不知道他当时是怎么想的，一些基本的分析、设计方法是十年，甚至二十年前的软件工程书中就讲到的，印度每个计算机专业的人员都是必修这些内容的。而我们除了对一些具体协议的代码很熟之外，对这些常用的方法似乎一无所知。我感到一些羞愧，进城直奔书店，把他给我开列的书找了出来，晚上躺在床上，仔细研读，我仿佛突然又遇到了能给我指点迷津的良师益友。现在印度所已形成了强烈的学习风气。我回来后也推销了700多本书，这些书教我们如何用工程化的方法开发软件，是成为一个软件工程师必读的资料。
+
+我们的项目经理的计划控制能力很强，当有什么影响到项目计划的事情发生时，如人员辞职、实验室搬家、某一模块预测不准（该模块是我们预测的），他总是采取必要的措施，减少延期，调整计划。刚开始，我们对他们每天上午11点，下午4点下楼喝咖啡还有点意见，后来也跟着喝去了，原来，喝咖啡时的交流非常丰富，从项目管理到设计方法，从技术发展到风土人情，无所不包，对我们互相之间的理解，对团队的气氛很有帮助。我们项目的qa也在适当的时候出现在我们的面前，我们对她的工作只有一些感性认识。她每次参加会议时，手里时常拿着一个check list，项目经理准备相应的资料，回答一些问题，她打着勾，或写着项目经理的解释。她给我们做培训时也很耐心，体现出很好的职业素养，我至今还在怀念她给我们的帮助。
+
+我从事软件开发已有四个年头了，可我现在仍然不能说自己是个合格的软件工程师，更不用谈什么合格的管理者。我看到一份报道说，瑞士洛桑一权威机构把中国的科技综合竞争力从原来的第十三位调到二十多位，原因是他们调整了一些评估标准，其中有一条是中国合格工程师的可获得性非常低。想着弟兄们熬红的双眼，四处奔波升级的疲惫身影，我有一个强烈的愿望：快把我们自己升级成合格的工程师吧!
\ No newline at end of file
diff --git a/blog/zh-cn/framework/agility.md b/blog/zh-cn/framework/agility.md
new file mode 100644
index 0000000..0c0b7fb
--- /dev/null
+++ b/blog/zh-cn/framework/agility.md
@@ -0,0 +1,77 @@
+# 如何理解敏捷开发
+
+## 为什么要敏捷开发
+
+“没有人喜欢敏捷，但我们不得不敏捷。就像没有人喜欢工作，但你必须工作。”这是我经常用来调侃敏捷的一句话。试想一下，拿到一份完整详尽的需求文档，逐个功能Coding，测试部署上线。不需要再次确认需求，不会有人打断思路。没有需求更改，只要自己不犯错，不存在推倒重来这才是大部分开发人员最舒服的工作方式吧，简直太完美了。但它很像瀑布，一点都不敏捷。既然我们喜欢的工作方式是传统的、瀑布的，为什么要敏捷？这还不都是市场环境逼的。今天的市场向我们提出了三个问题：
+
+## 01如何做出真正满足用户需求的产品？
+
+我不确定这世上是否有人可以做到，他所做出的全部决定都是对的。但绝大多数人是无法一次性做出真正满足用户需求的产品的。我们无法预测未来，我们必须通过一次次的测试，去寻找用户需要的产品是什么？想要更快地获得好的产品，必须迅速将产品推向市场，快速试验，避免走弯路。
+
+## 02如何满足不断变化的用户需求？
+
+今天所有的事情的都在快速变化，用户的需求也在变化。毫不夸张地说，我们正在全力开发的一些功能，当它们上线的时候，我们的用户已经不再需要了。我们没有办法让一切不变，我们只能选择去拥抱变化。
+
+## 03如何同时满足不同层次用户的需求？
+
+过去我们的产品会遵循产品生命周期，早期追求新奇的尝鲜者，中期普通大众，后期落后者。今天，产品的生命周期变化非常地快，我们可能会同时面对尝鲜者、普通大众、落后者，不同的用户类型的需求是不一样的，你如何满足他们？我们必须快速响应，没法快速响应，就没法留住用户，没有用户就没有一切。迅速将产品推向市场，拥抱变化、快速响应。今天的市场向所有的从业者提出了一个要求：拥有应对快速变化的需求的软件开发能力。而敏捷就是赋予团队应对快速变化的需求的软件开发能力的方法，而这就是敏捷流行的原因。
+
+## 什么是敏捷开发
+
+敏捷绝非某一种特定的开发方法，它只是一种应对快速变化的需求的一种软件开发能力。敏捷本身只包含了《敏捷软件开发宣言》和《敏捷软件的十二条原则》两份文档。敏捷相信，只要符合这两份文档的开发方法，就能让开发团队拥有应对快速变化需求的能力，这样的开发方法都叫做敏捷开发方法。
+
+## 最流行的敏捷开发方式是什么
+
+敏捷开发的方法有很多：ASD、AUP、DSDM、XP、FDD、Kanban、RAD、Scrum。目前国内最流行的应属Scrum。Scrum本意是指橄榄球运动中的“带球过人”，它可以解决非常复杂的项目，并且能高效并创造性地交付高价值的产品。Scrum包含3个角色、3个工件、5个价值观、5个事件 [详情https://www.scrum.org](https://www.scrum.org/)。相比其他敏捷方法，Scrum既不简单又不复杂。它有完善的指南，你可以按照指南，轻易在团队内推广尝试。但想要实践好Scrum，又需要很好的技巧。这种易上手难精通的方法，特别适合培训机构。所以近几年，关于Scrum的培训机构遍地都是。可以说，在Scrum流行这件事上，这些培训机构做了很大的贡献。
+
+## 如何实施Scrum
+
+在团队中实施敏捷开发是一个很有挑战性的工作，尤其是Scrum这种描述比较详细、有很多规则的方法。
+
+**如果你打算把所有人召集到一起，宣布我们要实施敏捷开发Scrum，然后就照着Scrum的描述开发方法直接实施，那么，你离失败不远了。**想要实施好Scrum，你必须一步步来，一点一点改变团队的习惯，当一项新制度已经变成本能之后，再推行下一项制度。
+
+### >>>>第一步，先把团队的开发任务可视化。
+
+你可以用一块白板，让团队成员把所有的开发任务都用便签写好放上去，也可以找一个专业的看板工具。我推荐日事清，当所有任务都在看板上，尽收眼底，那种感觉还是很棒的。团队中每个人的工作都会被所有人看到，会形成一种无形的监督。
+
+### >>>>第二步，引入站会制度。
+
+当团队所有人的任务都在看板后，这些任务的状态是需要有人更新的。无论是专人更新，还是每个人自己更新，都会出现忘记更新，更新不及时的情况。这时，就可以顺势引入站会制度了。每天上班的时候，或者每天下班的时候，所有人站到一起，花15分钟，说一下自己做了什么，准备做什么，所有人一起把看板更新了。
+
+### >>>>第三步，引入回顾会议
+
+当站会制度成熟后，就可以挑一个版本发布的日子。等版本发布后，把团队成员叫到一起，开一个回顾会。让团队成员对这个版本开发的情况做个总结，同时可以让大家用便签把这个开发版本遇到的问题、不满写下来。针对这些问题不满，大家一起讨论一些改进方案。
+
+### >>>>第四步，引入计划会议
+
+如果再开回顾会的时候，有人提出需求不清，拆解不够细致，工时估算不准之类的问题，那你真是太幸运了。碰到这种情况，你顺势提出这个制度：每个版本开发前，产品经理要和团队人员开个会，一起逐条对需求。产品经理要向团队解释每个需求，并且对团队提出的疑问进行解释和澄清。开发团队要将需求分解成任务，估算工时，最终形成一个开发清单。
+
+### >>>>第五步，引入评审会议
+
+当计划会成功开过几次之后，就可以考虑引入评审会了。你可以在某个重大功能发布的时候，把所有项目相关的人员召集起来，向大家展示团队做了哪些了不起的功能，也可以和大家讨论讨论还可以做哪些优化。
+
+### >>>>第六步，宣布引入Scrum
+
+当整个流程都跑顺以后，就可以在某次全体会议上，提出我们要实施Scrum了。你需要任命PO、SM，对团队培训Scrum知识，讲解Scrum的价值观。
+
+## 实施敏捷开发会面临怎样的挑战
+
+1.团队成员对变化的恐惧
+
+实施Scrum最大的挑战来自内部，来自团队对变化的恐惧。每个团队在运营一段时间后都会形成固有的默契和习惯，引入Scrum必然会打破这种习惯。这会让团队很不舒服，团队也会抵制，甚至是反抗。而且实施敏捷的过程，一定不是一帆风顺的，尤其是实施敏捷的早期阶段，不仅不会对团队产生太大的价值，反而会引起混乱。所以，在实施敏捷的过程中，千万要小心，每次只改变一点点，敏捷地完成敏捷。
+
+2.组织人员的专业化水
+
+平敏捷并不会直接提高团队的专业化水平，反而对团队专业化水平有一定的要求。必要的专业分工、合适的专业能力是必须的。敏捷会让开发整个流程持续运转，当某一个环节专业化能力出现问题的时候，会极大地导致整个流程运转停滞。平时团队中的问题会在敏捷中快速暴露。一旦出现专业水平问题，要及时解决，补充人员，或者帮助其提高能力。即使问题并不严重，也要在最短的时间解决，否则会影响团队对敏捷的信心。
+
+3.产品经理这个组织Bug
+
+国内在实施Scrum的时候经常会碰到的问题就是团队中会有产品经理这个角色。
+
+**一般的处理方法是产品经理当PO**，但PO是需要领导开发团队的。国内的产品经理往往不是技术出身，领导开发团队会出很多问题，所以产品经理并不适合当PO。
+
+**另一种做法是产品经理做利益相关者**，这种做法更不靠谱，利益相关者离团队太远，会出现无法及时响应的问题，时间长了也会导致产品和开发之间关系冷漠，出现隔阂。我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错
+
+我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错
+
+另外腾讯企业微信里[**TAPD**](https://www.tapd.cn)也是不错的
\ No newline at end of file
diff --git a/blog/zh-cn/framework/fwork.md b/blog/zh-cn/framework/fwork.md
new file mode 100644
index 0000000..598956f
--- /dev/null
+++ b/blog/zh-cn/framework/fwork.md
@@ -0,0 +1,143 @@
+# 走向架构师必备的技能
+
+中国有很多年轻人，他们18,9岁或21,2岁，通过自学也写了不少代码，他们有的代码写的很漂亮，一些技术细节相当出众，也很有钻研精神，但是他们被一些错误的认识和观点左右，缺乏对系统，对程序的整体理解能力，这些人，一个网上的朋友说得很好，他们实际fans，压根没有资格称为程序员，但是据我所知，不少小网络公司的Cfans,拿着吓人的工资，做着吓人的项目，项目的结局通常也很吓人。
+
+## 　程序员基本素质：
+
+作一个真正合格的程序员，或者说就是可以真正合格完成一些代码工作的程序员，应该具有的素质。
+
+1. 团队精神和协作能力 
+
+把它作为基本素质，并不是不重要，恰恰相反，这是程序员应该具备的最基本的，也是最重要的安身立命之本。把高水平程序员说成独行侠的都是在呓语，任何个人的力量都是有限的，即便如linus这样的天才，也需要通过组成强大的团队来创造奇迹，那些遍布全球的为linux写核心的高手们，没有协作精神是不可想象的。独行侠可以作一些赚钱的小软件发点小财，但是一旦进入一些大系统的研发团队，进入商业化和产品化的开发任务，缺乏这种素质的人就完全不合格了。
+
+2. 文档习惯 
+
+说高水平程序员从来不写文档的肯定是乳臭未干的毛孩子，良好的文档是正规研发流程中非常重要的环节，作为代码程序员，30％的工作时间写技术文档是很正常的，而作为高级程序员和系统分析员，这个比例还要高很多。缺乏文档，一个软件系统就缺乏生命力，在未来的查错，升级以及模块的复用时就都会遇到极大的麻烦。
+
+3. 规范化，标准化的代码编写习惯
+
+作为一些外国知名软件公司的规矩，代码的变量命名，代码内注释格式，甚至嵌套中行缩进的长度和函数间的空行数字都有明确规定，良好的编写习惯，不但有助于代码的移植和纠错，也有助于不同技术人员之间的协作。
+fans叫嚣高水平程序员写的代码旁人从来看不懂，这种叫嚣只能证明他们自己压根不配自称程序员。代码具有良好的可读性，是程序员基本的素质需求。
+再看看整个linux的搭建，没有规范化和标准化的代码习惯，全球的研发协作是绝对不可想象的。
+
+4. 需求理解能力 
+
+程序员需要理解一个模块的需求，很多小朋友写程序往往只关注一个功能需求，他们把性能指标全部归结到硬件，操作系统和开发环境上，而忽视了本身代码的性能考虑，有人曾经放言说写一个广 告交换程序很简单，这种人从来不知道在百万甚至千万数量级的访问情况下的性能指标是如何实现的，对于这样的程序员，你给他深蓝那套系统，他也做不出太极链的并访能力。性能需求指标中，稳定性，并访支撑能力以及安全性都很重要，作为程序员需要评估该模块在系统运营中所处的环境，将要受到的负荷压力以及各种潜在的危险和恶意攻击的可能性。就这一点，一个成熟的程序员至少需要2到3年的项目研发和跟踪经验才有可能有心得。
+
+5. 复用性，模块化思维能力 
+
+经常可以听到一些程序员有这样的抱怨，写了几年程序，变成了熟练工，每天都是重复写一些没有任何新意的代码，这其实是中国软件人才最大浪费的地方，一些重复性工作变成了熟练程序员的主要工作，而这些，其实是完全可以避免的。
+
+复用性设计，模块化思维就是要程序员在完成任何一个功能模块或函数的时候，要多想一些，不要局限在完成当前任务的简单思路上，想想看该模块是否可以脱离这个系统存在，是否可以通过简单的修改参数的方式在其他系统和应用环境下直接引用，这样就能极大避免重复性的开发工作，如果一个软件研发单位和工作组能够在每一次研发过程中都考虑到这些问题，那么程序员就不会在重复性的工作中耽误太多时间，就会有更多时间和精力投入到创新的代码工作中去。
+
+一些好的程序模块代码，即便是70年代写成的，拿到现在放到一些系统里面作为功能模块都能适合的很好，而现在我看到的是，很多小公司软件一升级或改进就动辄全部代码重写，大部分重复性工作无谓的浪费了时间和精力。
+
+6. 测试习惯 
+
+作为一些商业化正规化的开发而言，专职的测试工程师是不可少的，但是并不是说有了专职的测试工程师程序员就可以不进行自测；软件研发作为一项工程而言，一个很重要的特点就是问题发现的越早，解决的代价就越低，程序员在每段代码，每个子模块完成后进行认真的测试，就可以尽量将一些潜在的问题最早的发现和解决，这样对整体系统建设的效率和可靠性就有了最大的保证。
+
+测试工作实际上需要考虑两方面，一方面是正常调用的测试，也就是看程序是否能在正常调用下完成基本功能，这是最基本的测试职责，可惜在很多公司这成了唯一的测试任务，实际上还差的远那；第二方面就是异常调用的测试，比如高压力负荷下的稳定性测试，用户潜在的异常输入情况下的测试，整体系统局部故障情况下该模块受影响状况的测试，频发的异常请求阻塞资源时的模块稳定测试等等。当然并不是程序员要对自己的每段代码都需要进行这种完整测试，但是程序员必须清醒认识自己的代码任务在整体项目中的地位和各种性能需求，有针对性的进行相关测试并尽早发现和解决问题，当然这需要上面提到需求理解能力。
+
+7. 学习和总结的能力 
+
+程序员是人才很容易被淘汰，很容易落伍的职业，因为一种技术可能仅仅在三两年内具有领先性，程序员如果想安身立命，就必须不断跟进新的技术，学习新的技能。
+
+善于学习，对于任何职业而言，都是前进所必需的动力，对于程序员，这种要求就更加高了。但是学习也要找对目标，一些小coding有些codingTO就是这样的coding上只是一些Cfans们，他们也津津乐道于他们的学习能力，一会学会了asp，一会儿学会了php，一会儿学会了jsp，他们把这个作为炫耀的资本，盲目的追逐一些肤浅的，表面的东西和名词，做网络程序不懂通讯传输协议，做应用程序不懂中断向量处理，这样的技术人员，不管掌握了多少所谓的新语言，永远不会有质的提高。
+
+善于总结，也是学习能力的一种体现，每次完 成一个研发任务，完成一段代码，都应当有目的的跟踪该程序的应用状况和用户反馈，随时总结，找到自己的不足，这样逐步提高，一个程序员才可能成长起来。
+
+一个不具备成长性的程序员，即便眼前看是个高手，建议也不要选用，因为他落伍的时候马上就到了。具备以上全部素质的人，应当说是够格的程序员了，请注意以上的各种素质都不是由IQ决定的，也不是大学某些课本里可以学习到的，需要的仅仅是程序员对自己工作的认识，是一种意识上的问题。 
+
+
+## 高级程序员
+
+那么作为高级程序员，以至于系统分析员，也就是对于一个程序项目的设计者而言，除了应该具备上述全部素质之外，还需要具备以下素质：
+
+1. 需求分析能力 
+
+对于程序员而言，理解需求就可以完成合格的代码，但是对于研发项目的组织和管理者，他们不但要理解客户需求，更多时候还要自行制定一些需求，为什么这么说呢？
+
+一般而言，进行研发任务，也许是客户提出需求，也许是市场和营销部门提出的需求，这时候对于研发部门，他们看到的不是一个完整的需求，通常而言，该需求仅仅是一些功能上的要求，或者更正规些，可能获得一个完整的用户视图；但是这都不够，因为客户由于非技术因素多一些，他们可能很难提出完整和清晰，或者说专业性的性能需求，但是对于项目组织者和规划者，他必须能够清醒认识到这些需求的存在并在完成 需求分析报告的时候适当的提出，同时要完整和清晰的体现在设计说明书里面，以便于程序员编码时不会失去这些准则。
+
+程序设计者必须正确理解用户需求所处的环境，并针对性做出需求的分析，举例而言，同样一个软件通过ASP租用方式发布和通过License方式发布，性能需求可能就是有区别的，前者强调的是更好的支撑能力和稳定性，而后者则可能更强调在各种平台下的普适性和安装使用的简捷性。
+
+2. 项目设计方法和流程处理能力 
+
+程序设计者必须能够掌握不少于两到三种的项目设计方法（比如自顶至下的设计方法，比如快速原型法等等），并能够根据项目需求和资源搭配来选择合适的设计方法进行项 目的整体设计。设计方法上选择不当，就会耽误研发周期，浪费研发资源，甚至影响研发效果。
+
+一个程序设计者还需要把很多功夫用在流程图的设计和处理上，他需要做数据流图以确立数据词典；他需要加工逻辑流图以形成整体的系统处理流程。一个流程有问题的系统，就算代码多漂亮，每个模块多精致，也不会成为一个好的系统。当然，做好流程分析并选择好项目设计方法，都需要在需求分析能力上具有足够的把握。
+
+3. 复用设计和模块化分解能力 
+
+这个似乎又是老调重谈，前面基本素质上不是已经说明了这个问题吗？作为一个从事模块任务的程序员，他需要对他所面对的特定功能模块的 复用性进行考虑，而作为一个系统分析人员，他要面对的问题复杂的多，需要对整体系统按照一种模块化的分析能力分解为很多可复用的功能模块和函数，并针对每一模块形成一个独立的设计需求。举个例子，好比是汽车生产，最早每辆汽车都是独立安装的，每个部件都是量身定做的，但是后来不一样了，机器化大生产了，一个汽车厂开始通过流水线来生产汽车，独立部件开始具有一定的复用性，在后来标准化成为大趋势，不同型号，品牌甚至不同厂商的汽车部件也可以进行方便的换装和升级，这时候，汽车生产的效率达到最大化。软件工程也是同样的道理，一个成熟的软件行业，在一些相关项目和系统中，不同的部件是可以随意换装的，比如微软的许多桌面软件，在很多操作模块（如打开文件，保存文件等等）都是复用的同一套功能模块，而这些接口又通过一些类库提供给了桌面应用程序开发者方便挂接，这就是复用化的模块设计明显的一个佐证。
+
+将一个大型的，错综复杂的应用系统分解成一些相对独立的，具有高度复用性的，并能仅仅依靠几个参数完成数据联系的模块组合，是作为高级程序员和系统分析员一项最重要的工作，合适的项目设计方法，清晰的流程图，是实现这一目标的重要保证。
+
+4. 整体项目评估能力 
+
+作为系统设计人员，必须能够从全局出发，对项目又整体的清醒认识，比如公司的资源配置是否合理和到位，比如工程进度安排是否能最大化体现效率又不至于无法按期完成。评估项 目整体和各个模块的工作量，评估项目所需的资源，评估项目可能遇到的困难，都需要大量的经验积累，换言之，这是一种不断总结的累计才能达到的境界。在西方一些软件系统设计的带头人都是很年长的，比如4，50岁，甚至更老，他们在编码方面已经远远不如年轻人那样活络，但是就项目评估而言，他们几十年的经验积累就是最重要和宝贵的财富。中国缺这么一代程序员，主要还不是缺那种年纪的程序员，而是那种年纪的程序员基本上都是研究单位作出来的，都不是从专业的产品化软件研发作出来的，他们没有能积累那种产品化研发的经验，这也是没有办法的事情。
+
+5. 团队组织管理能力 
+
+完成一个项目工程，需要团队的齐心协力，作为项目设计者或研发的主管人，就应当有能力最大化发挥团队的整体力量，技术管理由于其专业性质，不大同于一般的人事管理，因为这里面设计了一些技术性的指标和因素。
+
+首先是工作的量化，没有量化就很难做到合适的绩效考核，而程序量化又不是简单的代码行数可以计算的，因此要求技术管理人员需要能真正评估一个模块的复杂性和工作量。
+
+其次是对团队协作模式的调整，一般而言，程序开发的协作通常分为小组进行，小组有主程序员方式的，也有民主方式的，根据程序员之间的能力水平差距，以及根据项目研发的需求，选择合适的组队方式，并能将责权和成员的工作任务紧密结合，这样才能最大发挥组队的效率。
+
+一个代码水平高的人，未必能成为一个合格的项目研发主管，这方面的能力欠缺往往是容易被忽视的。
+
+综上可以看到，作为一个主管研发的负责人，一个项目设计者，所需要具备的素质和能力并不是程序代码编写的能力，当然一般情况下，一个程序员通过不断的总结提高达到了这种素质的时候，他所具有的代码编写能力也已经相当不简单了，但是请注意这里面的因果关系，一个高水平的项目设计者通常已经是代码编写相当优秀的人了，但是并不是一个代码相当优秀的程序员就可以胜任项目设计的工作，这里面存在的也不是智商和课本的问题，还是在于一个程序员在积累经验，逐步提升的时候没有意识到应当思考哪方面的东西，没有有意识的就项目的组织和复用设计进行揣摩，没有经常性的文档习惯和总结习惯， 不改变这些，我们的合格的项目设计者还是非常欠缺。
+
+另外，为防止有无聊的人和我较真，补充一点，本文针对目标是作商业化的软件项目和工程，那些科研机构的编程高手，比如算法高手，比如图象处理高手，他们的工作是研究课题而非直接完成商业软件（当然最终间接成为商业产品，比如微软研究院在作的研究课题），因此他们强调的素质可能是另外的东西，这些人（专家），并不能说是程序员，不能用程序员的标准去衡量。
+
+最后补充一点东西，一个软件项目研发的设计流程是怎样的呢？以通常标准的设计方法为例，（不过笔者喜欢快速原型法）。
+
+* 第一个步骤是市场调研，技术和市场要结合才能体现最大价值。 
+
+* 第二个步骤是需求分析，这个阶段需要出三样东西，用户视图，数据词典和用户操作手册。用户视图是该软件用户（包括终端用户和管理用户）所能看到的页面样式，这里面包含了很多操作方面的流程和条件。数据词典是指明数据逻辑关系并加以整理的东东，完成了数据词典，数据库的设计就完成了一半多。用户操作手册是指明了操作流程的说明书。
+
+注意，用户操作流程和用户视图是由需求决定的，因此应该在软件设计之前完成，完成这些，就为程序研发提供了约束和准绳，很遗憾太多公司都不是这样做的，因果颠倒，顺序不分，开发工作和实际需求往往因此 产生隔阂脱节的现象。
+
+需求分析，除了以上工作，笔者以为作为项目设计者应当完整的做出项目的性能需求说明书，因为往往性能需求只有懂技术的人才可能理解，这就需要技术专家和需求方（客户或公司市场部门）能够有真正的沟通和了解。
+
+* 第三个步骤是概要设计，将系统功能模块初步划分，并给出合理的研发流程和资源要求。作为快速原型设计方法，完成概要设计就可以进入编码阶段了，通常采用这种方法是因为涉及的研发任务属于新领域，技术主管人员一上来无法给出明确的详细设计说明书，但是并不是说详细设计说明书不重要，事实上快速原型法在完成原型代码后，根据评测结果和经验教训的总结，还要重新进行详细设计的步骤。 
+
+* 第四个步骤是详细设计，这是考验技术专家设计思维的重 要关卡，详细设计说明书应当把具体的模块以最‘干净’的方式(黑箱结构）提供给编码者，使得系统整体模块化达到最大；一份好的详细设计说明书，可以使编码的复杂性减低到最低，实际上，严格的讲详细设计说明书应当把每个函数的每个参数的定义都精精细细的提供出来，从需求分析到概要设计到完成详细设计说明书，一个软件项目就应当说完成了一半了。换言之，一个大型软件系统在完成了一半的时候，其实还没有开始一行代码工作。那些把作软件的程序员简单理解为写代码的，就从根子上犯了错误了。 
+
+* 第五个步骤是编码，在规范化的研发流程中，编码工作在整个项目流程里最多不会超过1/2，通常在1/3的时间，所谓磨刀不误砍柴功，设计过程完成的好，编码效率就会极大提高，编码时不同模块之间的进度协调和协作是最需要小心的，也许一个小模块的问题就可能影响了整体进度，让很多程序员因此被迫停下工作等待，这种问题在很多研发过程中都出现过。编码时的相互沟通和应急的解决手段都是相当重要的，对于程序员而言，bug永远存在，你必须永远面对这个问题，大名鼎鼎的微软，可曾有连续三个月不发补丁的时候吗？从来没有！
+
+*  第六个步骤是测试 
+
+测试有很多种：按照测试执行方，可以分为内部测试和外部测试；按照测试范围，可以分为模块测试和整体联调；按照测试条 件，可以分为正常操作情况测试和异常情况测试；按照测试的输入范围，可以分为全覆盖测试和抽样测试。以上都很好理解，不再解释。
+
+总之，测试同样是项目研发中一个相当重要的步骤，对于一个大型软件，3个月到1年的外部测试都是正常的，因为永远都会又不可预料的问题存在。
+
+完成测试后，完成验收并完成最后的一些帮助文档，整体项目才算告一段落，当然日后少不了升级，修补等等工作，只要不是想通过一锤子买卖骗钱，就要不停的跟踪软件的运营状况并持续修补升级，知道这个软件被彻底淘汰为止。
+
+写这些步骤算不上卖弄什么，因为实话讲我手边是一本《软件工程》，在大学里这是计算机专业的必修课程，但是我知道很多程序员似乎从来都只是热衷于什么《30天精通VC》之类的，他们有些和我一样游击队出身，没有正规学过这个专业，还有一些则早就在混够学分后就把这些真正有用的东西还给了老师。
+
+fans乱嚷嚷，混淆视听，实际上真正的技术专家很少在网上乱发帖子的，如笔者这样不知天高地厚的，其实实在是算不上什么高手，只不过看不惯这种对技术，对程序员的误解和胡说，只好挺身而出，做拨乱反正之言，也希望那些还fans们能认真想想，走到正途上，毕竟那些聪明的头脑还远远没有发挥应有的价值。沉迷于一些错误人士的coding
+
+从程序员升级到工程师大多数象我这样对软件有浓厚兴趣的人，毕业后义无反顾地走进了企业，开始了程序员的生涯。那时，我们迷恋“大全”、“秘籍”一类的书籍，心中只有代码。当我看到一行行枯燥的代码变成了能够打电话的设备，变成了屏幕上漂亮的表格，变成了动听的音乐，成就感油然而生。我觉得自己也是一个出色的程序员了。在用户的机房中苦熬三昼夜解决软件的bug，也成了一种可以夸耀的资历。五年前的某一天，我把曾经让我兴奋自豪的大量代码和少得可怜的文档移交之后，来到了华为。这里有更多的年轻人，我如鱼得水，可以充分发挥自己的想象力。依然是代码，依然是匆匆地在纸上记下稍纵即逝的灵感（我们把它称作文档），依然是无休止地和bug作斗争。当有一天，一个新来 的同事拿着署着我的大名的文档，小心翼翼地来问我时，我发现自己好象有点不认识它了。我心里有点沮丧，再看看代码，发现文档上记录的一些灵感已面目全非。我当时不知道那位新来的同事感受如何，但我从那时起，好象意识到什么。现在来看，那时的很多事情都是事倍功半。
+
+去年年底，我学习印度从事项目开发，学习印度的软件开发管理方法。一种久违的冲动在心底升起。我在学习过程中和印度的工程师交流过，他们言谈中透着自信。他们给我讲解正在做的软件的测试环境，给我看他们写的单元测试文档。当我看到一个软件模块的单元测试用例有三百多页时，我觉得心里很是沉重。当我第三次踏上这片土地时，我又见到了熟悉的人们，明亮的眼睛，温和的笑容，随意的穿着，风驰电掣的摩托，还有大学校园中穿着拖鞋，手抱书本的年轻人。
+
+我也见到了我的项目经理，一个个子较高，瘦瘦的年轻人，据说刚从美国回来，已工作了五、六年。我听了心里很高兴，这回要一招一式地学两手。需求分析的时间是一个月，项目经理和我们（实际上代表客户 ）讨论了proposal中的内容，确定每一项都是需要的。然后他把模块大致划分了一下，开始进入计划中的学习阶段。每个人在学习阶段要写出功能描述的胶片，给其他人讲解，不知不觉中，项目组的所有人对项目有了整体的了解。
+
+
+　他还安排了一些培训，如他们公司的软件开发模型、项目组中各角色的定义，以后及时的培训不断，只要项目组中有需求，他总是把qa或相关的人请来，培训很专业。需求分析完成后提交了一份四十多页的文档，当我看到这份英文文档中我写的部分整整齐齐地列在其中时，我的感觉很复杂，有些喜悦，但更多的是苦涩，我以前怎么就从来没有这样做过需求分析呢。
+
+在我写文档的过程中，qa给我们培训过srs的写作模板，后来我还是不放心，让他们一个有经验的工程师写了一段，我们再琢磨着照着写。这份srs虽然是多个人合写，但风格一致，内容详实。更为可贵的是，一直到最后，这份需求分析的内容都没有改过，以至于我们没有机会走一下他们的需求更改流程。
+
+需求分析是项目的第一阶段，第二阶段的开发时间要根据需求分析的结果来确定。当对方的首席技术官（相当于我们业务部的总体组长）来和我们讨论计划时，他们已列出了对每个 模块的代码行数的预测，可能存在的风险。根据他们公司的生产率－－300行/人月，他得出了项目第二阶段需要多少周。
+
+我们当时就提出了异议：1）公司对该项目需求很急；2）每月300行是否太少；3）我们还有下载的源代码参考。他解释说，300行/人月是使得项目能达到他们质量标准的经验数据，考虑到有源代码参考，生产率最多不能超过350行/人月。
+
+　当他问我们公司的生产率时，我脑袋里转了三个圈，没敢多说，大概六、七百行吧。他沉默了一会儿，然后坚定地说，我们这个计划是建立在确保质量的基础上的，我想你们到印度来开发软件，首先看中的应该是我们印度公司的质量保证。我知道你们不缺乏软件开发人员，你们为什么不选择下载的软件呢。几句话说到了我的痛处，现在国内的弟兄们还在为使用下载软件移植的产品四处奔波呢！
+
+　随后的开发活动有条不紊，我们老老实实地跟着做。系统测试计划、用例，概要设计，集成测试计划、用例，详细设计，单元测试计划、用例，编码，单元测试，集成测试，系统测试。一个完整的v模型开发过程，其中每个过程都有review。当我们对一些设计的方法不太明白时，项目经理给我们发来了相关的资料，我不知道他当时是怎么想的，一些基本的分析、设计方法是十年，甚至二十年前的软件工程书中就讲到的，印度每个计算机专业的人员都是必修这些内容的。而我们除了对一些具体协议的代码很熟之外，对这些常用的方法似乎一无所知。我感到一些羞愧，进城直奔书店，把他给我开列的书找了出来，晚上躺在床上，仔细研读，我仿佛突然又遇到了能给我指点迷津的良师益友。现在印度所已形成了强烈的学习风气。我回来后也推销了700多本书，这些书教我们如何用工程化的方法开发软件，是成为一个软件工程师必读的资料。
+
+我们的项目经理的计划控制能力很强，当有什么影响到项目计划的事情发生时，如人员辞职、实验室搬家、某一模块预测不准（该模块是我们预测的），他总是采取必要的措施，减少延期，调整计划。刚开始，我们对他们每天上午11点，下午4点下楼喝咖啡还有点意见，后来也跟着喝去了，原来，喝咖啡时的交流非常丰富，从项目管理到设计方法，从技术发展到风土人情，无所不包，对我们互相之间的理解，对团队的气氛很有帮助。我们项目的qa也在适当的时候出现在我们的面前，我们对她的工作只有一些感性认识。她每次参加会议时，手里时常拿着一个check list，项目经理准备相应的资料，回答一些问题，她打着勾，或写着项目经理的解释。她给我们做培训时也很耐心，体现出很好的职业素养，我至今还在怀念她给我们的帮助。
+
+我从事软件开发已有四个年头了，可我现在仍然不能说自己是个合格的软件工程师，更不用谈什么合格的管理者。我看到一份报道说，瑞士洛桑一权威机构把中国的科技综合竞争力从原来的第十三位调到二十多位，原因是他们调整了一些评估标准，其中有一条是中国合格工程师的可获得性非常低。想着弟兄们熬红的双眼，四处奔波升级的疲惫身影，我有一个强烈的愿望：快把我们自己升级成合格的工程师吧!
\ No newline at end of file
diff --git a/build/blog.js b/build/blog.js
index 2696780..c7531f4 100644
--- a/build/blog.js
+++ b/build/blog.js
@@ -1,6 +1,6 @@
-!function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="/build/",t(t.s=78)}([function(e,t,n){"use strict";function r(e,t,n,r){n&&Object.defineProperty(e,t,{enumerable:n.enumerable,configurable:n.configurable,writable:n.writable,value:n.initializer?n.initializer.call(r):void 0})}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t,n,r,o){var a={};return Object.keys(r).forEach(function(e){a[e]=r[e]}),a.enumerable=!!a.enumerable,a.configurable=!!a.configurable,("value"in a||a.initializer)&&(a.writable=!0),a=n.slice().reverse().reduce(function(n,r){return r(e,t,n)||n},a),o&&void 0!==a.initializer&&(a.value=a.initializer?a.initializer.call(o):void 0,a.initializer=void 0),void 0===a.initializer&&(Object.defineProperty(e,t,a),a=null),a}function i(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}function u(e){if(!e||!e.hasOwnProperty)return!1;for(var t=["value","initializer","get","set"],n=0,r=t.length;n<r;n++)if(e.hasOwnProperty(t[n]))return!0;return!1}function l(e,t){return u(t[t.length-1])?e.apply(void 0,i(t).concat([[]])):function(){return e.apply(void 0,i(Array.prototype.slice.call(arguments)).concat([t]))}}function c(e){return!1===e.hasOwnProperty(P)&&k(e,P,{value:new S}),e[P]}function s(e){var t={};return x(e).forEach(function(n){return t[n]=_(e,n)}),t}function f(e){return function(t){return Object.defineProperty(this,e,{configurable:!0,writable:!0,enumerable:!0,value:t}),t}}function d(e,t){return e.bind?e.bind(t):function(){return e.apply(t,arguments)}}function p(e){!0!==M[e]&&(M[e]=!0,T("DEPRECATION: "+e))}t.d=l,t.c=c,n.d(t,"g",function(){return x}),t.f=s,t.e=f,t.a=d,n.d(t,"b",function(){return T}),t.h=p;var h,y,m,g,v,b,w=n(8),O="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},k=Object.defineProperty,_=Object.getOwnPropertyDescriptor,E=Object.getOwnPropertyNames,j=Object.getOwnPropertySymbols,S=(h=function e(){o(this,e),r(this,"debounceTimeoutIds",y,this),r(this,"throttleTimeoutIds",m,this),r(this,"throttlePreviousTimestamps",g,this),r(this,"throttleTrailingArgs",v,this),r(this,"profileLastRan",b,this)},y=a(h.prototype,"debounceTimeoutIds",[w.a],{enumerable:!0,initializer:function(){return{}}}),m=a(h.prototype,"throttleTimeoutIds",[w.a],{enumerable:!0,initializer:function(){return{}}}),g=a(h.prototype,"throttlePreviousTimestamps",[w.a],{enumerable:!0,initializer:function(){return{}}}),v=a(h.prototype,"throttleTrailingArgs",[w.a],{enumerable:!0,initializer:function(){return null}}),b=a(h.prototype,"profileLastRan",[w.a],{enumerable:!0,initializer:function(){return null}}),h),P="function"==typeof Symbol?Symbol("__core_decorators__"):"__core_decorators__",x=j?function(e){return E(e).concat(j(e))}:E,T=function(){return"object"===("undefined"==typeof console?"undefined":O(console))&&console&&"function"==typeof console.warn?d(console.warn,console):function(){}}(),M={}},function(e,t){e.exports=React},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});t.throttle=function(e,t){var n=null;return function(){for(var r=arguments.length,o=Array(r),a=0;a<r;a++)o[a]=arguments[a];var i=this;clearTimeout(n),n=setTimeout(function(){e.apply(i,o)},t)}},t.getScrollTop=function(){var e=0;return document.documentElement&&document.documentElement.scrollTop?e=document.documentElement.scrollTop:document.body&&(e=document.body.scrollTop),e},t.getLink=function(e){return(""+e).length>1&&/^\/[^\/]/.test(""+e)?""+window.rootPath+e:e},t.parseJSONStr=function(e){try{return JSON.parse(e)}catch(t){return e}}},function(e,t,n){e.exports=n(33)()},function(e,t){e.exports=ReactDOM},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=n(24);n.d(t,"override",function(){return r.a});var o=n(17);n.d(t,"deprecate",function(){return o.a}),n.d(t,"deprecated",function(){return o.a});var a=n(27);n.d(t,"suppressWarnings",function(){return a.a});var i=n(20);n.d(t,"memoize",function(){return i.a});var u=n(14);n.d(t,"autobind",function(){return u.a});var l=n(26);n.d(t,"readonly",function(){return l.a});var c=n(18);n.d(t,"enumerable",function(){return c.a});var s=n(23);n.d(t,"nonenumerable",function(){return s.a});var f=n(22);n.d(t,"nonconfigurable",function(){return f.a});var d=n(15);n.d(t,"debounce",function(){return d.a});var p=n(28);n.d(t,"throttle",function(){return p.a});var h=n(16);n.d(t,"decorate",function(){return h.a});var y=n(21);n.d(t,"mixin",function(){return y.a}),n.d(t,"mixins",function(){return y.a});var m=n(8);n.d(t,"lazyInitialize",function(){return m.a});var g=n(29);n.d(t,"time",function(){return g.a});var v=n(19);n.d(t,"extendDescriptor",function(){return v.a});var b=n(25);n.d(t,"profile",function(){return b.a});var w=n(13);n.d(t,"applyDecorators",function(){return w.a})},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default={rootPath:"",port:8080,domain:"yangfubing.github.io",defaultSearch:"baidu",defaultLanguage:"zh-cn","en-us":{pageMenu:[{key:"home",text:"HOME",link:"/en-us/index.html"},{key:"docs",text:"DOCS",link:"/en-us/docs/introduction.html"},{key:"blog",text:"BLOG",link:"/en-us/blog/index.html"},{key:"community",text:"COMMUNITY",link:"/en-us/community/index.html"}],disclaimer:{title:"Disclaimer",content:"the disclaimer content"},documentation:{title:"Documentation",list:[{text:"Overview",link:"/en-us/docs/introduction.html"},{text:"Quick start",link:"/en-us/docs/introduction.html"},{text:"Developer guide",link:"/en-us/docs/dir/introduction.html"}]},resources:{title:"Resources",list:[{text:"Blog",link:"/en-us/blog/index.html"},{text:"Community",link:"/en-us/community/index.html"}]},copyright:"Copyright © 2018 BurningMyself"},"zh-cn":{pageMenu:[{key:"home",text:"首页",link:"/zh-cn/index.html"},{key:"docs",text:"文档",link:"/zh-cn/docs/introduction.html"},{key:"blog",text:"博客",link:"/zh-cn/blog/index.html"},{key:"community",text:"社区",link:"/zh-cn/community/index.html"}],disclaimer:{title:"免责声明",content:"免责声明的具体内容"},documentation:{title:"文档",list:[{text:"概览",link:"/zh-cn/docs/introduction.html"},{text:"快速开始",link:"/zh-cn/docs/introduction.html"},{text:"开发者指南",link:"/zh-cn/docs/dir/introduction.html"}]},resources:{title:"资源",list:[{text:"博客",link:"/zh-cn/blog/index.html"},{text:"社区",link:"/zh-cn/community/index.html"}]},copyright:"Copyright © 2018 BurningMyself"}}},function(e,t,n){var r,o;/*!
+!function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="/build/",t(t.s=78)}([function(e,t,n){"use strict";function r(e,t,n,r){n&&Object.defineProperty(e,t,{enumerable:n.enumerable,configurable:n.configurable,writable:n.writable,value:n.initializer?n.initializer.call(r):void 0})}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t,n,r,o){var a={};return Object.keys(r).forEach(function(e){a[e]=r[e]}),a.enumerable=!!a.enumerable,a.configurable=!!a.configurable,("value"in a||a.initializer)&&(a.writable=!0),a=n.slice().reverse().reduce(function(n,r){return r(e,t,n)||n},a),o&&void 0!==a.initializer&&(a.value=a.initializer?a.initializer.call(o):void 0,a.initializer=void 0),void 0===a.initializer&&(Object.defineProperty(e,t,a),a=null),a}function i(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}function u(e){if(!e||!e.hasOwnProperty)return!1;for(var t=["value","initializer","get","set"],n=0,r=t.length;n<r;n++)if(e.hasOwnProperty(t[n]))return!0;return!1}function l(e,t){return u(t[t.length-1])?e.apply(void 0,i(t).concat([[]])):function(){return e.apply(void 0,i(Array.prototype.slice.call(arguments)).concat([t]))}}function c(e){return!1===e.hasOwnProperty(P)&&k(e,P,{value:new S}),e[P]}function s(e){var t={};return x(e).forEach(function(n){return t[n]=_(e,n)}),t}function f(e){return function(t){return Object.defineProperty(this,e,{configurable:!0,writable:!0,enumerable:!0,value:t}),t}}function d(e,t){return e.bind?e.bind(t):function(){return e.apply(t,arguments)}}function p(e){!0!==T[e]&&(T[e]=!0,M("DEPRECATION: "+e))}t.d=l,t.c=c,n.d(t,"g",function(){return x}),t.f=s,t.e=f,t.a=d,n.d(t,"b",function(){return M}),t.h=p;var h,y,g,m,v,b,w=n(8),O="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},k=Object.defineProperty,_=Object.getOwnPropertyDescriptor,E=Object.getOwnPropertyNames,j=Object.getOwnPropertySymbols,S=(h=function e(){o(this,e),r(this,"debounceTimeoutIds",y,this),r(this,"throttleTimeoutIds",g,this),r(this,"throttlePreviousTimestamps",m,this),r(this,"throttleTrailingArgs",v,this),r(this,"profileLastRan",b,this)},y=a(h.prototype,"debounceTimeoutIds",[w.a],{enumerable:!0,initializer:function(){return{}}}),g=a(h.prototype,"throttleTimeoutIds",[w.a],{enumerable:!0,initializer:function(){return{}}}),m=a(h.prototype,"throttlePreviousTimestamps",[w.a],{enumerable:!0,initializer:function(){return{}}}),v=a(h.prototype,"throttleTrailingArgs",[w.a],{enumerable:!0,initializer:function(){return null}}),b=a(h.prototype,"profileLastRan",[w.a],{enumerable:!0,initializer:function(){return null}}),h),P="function"==typeof Symbol?Symbol("__core_decorators__"):"__core_decorators__",x=j?function(e){return E(e).concat(j(e))}:E,M=function(){return"object"===("undefined"==typeof console?"undefined":O(console))&&console&&"function"==typeof console.warn?d(console.warn,console):function(){}}(),T={}},function(e,t){e.exports=React},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});t.throttle=function(e,t){var n=null;return function(){for(var r=arguments.length,o=Array(r),a=0;a<r;a++)o[a]=arguments[a];var i=this;clearTimeout(n),n=setTimeout(function(){e.apply(i,o)},t)}},t.getScrollTop=function(){var e=0;return document.documentElement&&document.documentElement.scrollTop?e=document.documentElement.scrollTop:document.body&&(e=document.body.scrollTop),e},t.getLink=function(e){return(""+e).length>1&&/^\/[^\/]/.test(""+e)?""+window.rootPath+e:e},t.parseJSONStr=function(e){try{return JSON.parse(e)}catch(t){return e}}},function(e,t,n){e.exports=n(33)()},function(e,t){e.exports=ReactDOM},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=n(24);n.d(t,"override",function(){return r.a});var o=n(17);n.d(t,"deprecate",function(){return o.a}),n.d(t,"deprecated",function(){return o.a});var a=n(27);n.d(t,"suppressWarnings",function(){return a.a});var i=n(20);n.d(t,"memoize",function(){return i.a});var u=n(14);n.d(t,"autobind",function(){return u.a});var l=n(26);n.d(t,"readonly",function(){return l.a});var c=n(18);n.d(t,"enumerable",function(){return c.a});var s=n(23);n.d(t,"nonenumerable",function(){return s.a});var f=n(22);n.d(t,"nonconfigurable",function(){return f.a});var d=n(15);n.d(t,"debounce",function(){return d.a});var p=n(28);n.d(t,"throttle",function(){return p.a});var h=n(16);n.d(t,"decorate",function(){return h.a});var y=n(21);n.d(t,"mixin",function(){return y.a}),n.d(t,"mixins",function(){return y.a});var g=n(8);n.d(t,"lazyInitialize",function(){return g.a});var m=n(29);n.d(t,"time",function(){return m.a});var v=n(19);n.d(t,"extendDescriptor",function(){return v.a});var b=n(25);n.d(t,"profile",function(){return b.a});var w=n(13);n.d(t,"applyDecorators",function(){return w.a})},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default={rootPath:"",port:8080,domain:"yangfubing.github.io",defaultSearch:"baidu",defaultLanguage:"zh-cn","en-us":{pageMenu:[{key:"home",text:"HOME",link:"/en-us/index.html"},{key:"docs",text:"DOCS",link:"/en-us/docs/introduction.html"},{key:"blog",text:"BLOG",link:"/en-us/blog/index.html"},{key:"community",text:"COMMUNITY",link:"/en-us/community/index.html"}],disclaimer:{title:"Disclaimer",content:"the disclaimer content"},documentation:{title:"Documentation",list:[{text:"Overview",link:"/en-us/docs/introduction.html"},{text:"Quick start",link:"/en-us/docs/introduction.html"},{text:"Developer guide",link:"/en-us/docs/dir/introduction.html"}]},resources:{title:"Resources",list:[{text:"Blog",link:"/en-us/blog/index.html"},{text:"Community",link:"/en-us/community/index.html"}]},copyright:"Copyright © 2018 BurningMyself"},"zh-cn":{pageMenu:[{key:"home",text:"首页",link:"/zh-cn/index.html"},{key:"docs",text:"文档",link:"/zh-cn/docs/introduction.html"},{key:"blog",text:"博客",link:"/zh-cn/blog/index.html"},{key:"community",text:"社区",link:"/zh-cn/community/index.html"}],disclaimer:{title:"免责声明",content:"免责声明的具体内容"},documentation:{title:"文档",list:[{text:"概览",link:"/zh-cn/docs/introduction.html"},{text:"快速开始",link:"/zh-cn/docs/introduction.html"},{text:"开发者指南",link:"/zh-cn/docs/dir/introduction.html"}]},resources:{title:"资源",list:[{text:"博客",link:"/zh-cn/blog/index.html"},{text:"社区",link:"/zh-cn/community/index.html"}]},copyright:"Copyright © 2018 BurningMyself"}}},function(e,t,n){var r,o;/*!
   Copyright (c) 2017 Jed Watson.
   Licensed under the MIT License (MIT), see
   http://jedwatson.github.io/classnames
 */
-!function(){"use strict";function n(){for(var e=[],t=0;t<arguments.length;t++){var r=arguments[t];if(r){var o=typeof r;if("string"===o||"number"===o)e.push(r);else if(Array.isArray(r)&&r.length){var i=n.apply(null,r);i&&e.push(i)}else if("object"===o)for(var u in r)a.call(r,u)&&r[u]&&e.push(u)}}return e.join(" ")}var a={}.hasOwnProperty;void 0!==e&&e.exports?(n.default=n,e.exports=n):(r=[],void 0!==(o=function(){return n}.apply(t,r))&&(e.exports=o))}()},function(e,t,n){"use strict";function r(e,t,r){var o=r.configurable,u=r.enumerable,l=r.initializer,c=r.value;return{configurable:o,enumerable:u,get:function(){if(this!==e){var n=l?l.call(this):c;return i(this,t,{configurable:o,enumerable:u,writable:!0,value:n}),n}},set:n.i(a.e)(t)}}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.defineProperty},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),l=n(1),c=r(l),s=n(3),f=r(s),d=n(6),p=r(d),h=n(2);n(30);var y={logo:f.default.string.isRequired,language:f.default.oneOf(["zh-cn","en-us"])},m=function(e){function t(){return o(this,t),a(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return i(t,e),u(t,[{key:"render",value:function(){var e=this.props,t=e.logo,n=e.language,r=p.default[n];return c.default.createElement("footer",{className:"footer-container"},c.default.createElement("div",{className:"footer-body"},c.default.createElement("img",{src:(0,h.getLink)(t)}),c.default.createElement("div",{className:"cols-container"},c.default.createElement("div",{className:"col col-12"},c.default.createElement("h3",null,r.disclaimer.title),c.default.createElement("p",null,r.disclaimer.content)),c.default.createElement("div",{className:"col col-6"},c.default.createElement("dl",null,c.default.createElement("dt",null,r.documentation.title),r.documentation.list.map(function(e,t){return c.default.createElement("dd",{key:t},c.default.createElement("a",{href:(0,h.getLink)(e.link),target:e.target||"_self"},e.text))}))),c.default.createElement("div",{className:"col col-6"},c.default.createElement("dl",null,c.default.createElement("dt",null,r.resources.title),r.resources.list.map(function(e,t){return c.default.createElement("dd",{key:t},c.default.createElement("a",{href:(0,h.getLink)(e.link),target:e.target||"_self"},e.text))})))),c.default.createElement("div",{className:"copyright"},c.default.createElement("span",null,r.copyright))))}}]),t}(c.default.Component);m.propTypes=y,t.default=m},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function a(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var l,c=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),s=n(1),f=r(s),d=n(3),p=r(d),h=n(7),y=r(h),m=n(5),g=n(6),v=r(g),b=n(2);n(31);var w=[{text:"中",value:"en-us"},{text:"En",value:"zh-cn"}],O={baidu:{logo:"https://img.alicdn.com/tfs/TB1n6DQayLaK1RjSZFxXXamPFXa-300-300.png",url:"https://www.baidu.com/s?wd="},google:{logo:"https://img.alicdn.com/tfs/TB1REfuaCzqK1RjSZFjXXblCFXa-300-300.jpg",url:"https://www.google.com/search?q="}},k=function(){},_={currentKey:p.default.string,logo:p.default.string.isRequired,type:p.default.oneOf(["primary","normal"]),language:p.default.oneOf(["en-us","zh-cn"]),onLanguageChange:p.default.func},E={type:"primary",language:"en-us",onLanguageChange:k},j=(0,m.autobind)(l=function(e){function t(e){a(this,t);var n=i(this,(t.__proto__||Object.getPrototypeOf(t)).call(this,e));return n.state={menuBodyVisible:!1,language:e.language,search:v.default.defaultSearch,searchValue:"",inputVisible:!1},n}return u(t,e),c(t,[{key:"componentWillReceiveProps",value:function(e){this.setState({language:e.language})}},{key:"toggleMenu",value:function(){this.setState({menuBodyVisible:!this.state.menuBodyVisible})}},{key:"switchLang",value:function(){var e=void 0;e="zh-cn"===this.state.language?"en-us":"zh-cn",this.setState({language:e}),this.props.onLanguageChange(e)}},{key:"switchSearch",value:function(){var e=void 0;e="baidu"===this.state.search?"google":"baidu",this.setState({search:e})}},{key:"toggleSearch",value:function(){this.setState({searchVisible:!this.state.searchVisible})}},{key:"onInputChange",value:function(e){this.setState({searchValue:e.target.value})}},{key:"goSearch",value:function(){var e=this.state,t=e.search,n=e.searchValue;window.open(""+O[t].url+window.encodeURIComponent(n+" site:"+v.default.domain))}},{key:"onKeyDown",value:function(e){13===e.keyCode&&this.goSearch()}},{key:"render",value:function(){var e=this.props,t=e.type,n=e.logo,r=e.onLanguageChange,a=e.currentKey,i=this.state,u=i.menuBodyVisible,l=i.language,c=i.search,s=i.searchVisible;return f.default.createElement("header",{className:(0,y.default)(o({"header-container":!0},"header-container-"+t,!0))},f.default.createElement("div",{className:"header-body"},f.default.createElement("a",{href:(0,b.getLink)("/"+l+"/index.html")},f.default.createElement("img",{className:"logo",alt:v.default.name,title:v.default.name,src:(0,b.getLink)(n)})),v.default.defaultSearch?f.default.createElement("div",{className:(0,y.default)(o({search:!0},"search-"+t,!0))},f.default.createElement("span",{className:"icon-search",onClick:this.toggleSearch}),s?f.default.createElement("div",{className:"search-input"},f.default.createElement("img",{src:O[c].logo,onClick:this.switchSearch}),f.default.createElement("input",{autoFocus:!0,onChange:this.onInputChange,onKeyDown:this.onKeyDown})):null):null,r!==k?f.default.createElement("span",{className:(0,y.default)(o({"language-switch":!0},"language-switch-"+t,!0)),onClick:this.switchLang},w.find(function(e){return e.value===l}).text):null,f.default.createElement("div",{className:(0,y.default)({"header-menu":!0,"header-menu-open":u})},f.default.createElement("img",{className:"header-menu-toggle",onClick:this.toggleMenu,src:"primary"===t?(0,b.getLink)("/img/system/menu_white.png"):(0,b.getLink)("/img/system/menu_gray.png")}),f.default.createElement("ul",null,v.default[l].pageMenu.map(function(e){var n;return f.default.createElement("li",{className:(0,y.default)((n={"menu-item":!0},o(n,"menu-item-"+t,!0),o(n,"menu-item-"+t+"-active",a===e.key),n)),key:e.key},f.default.createElement("a",{href:(0,b.getLink)(e.link),target:e.target||"_self"},e.text))})))))}}]),t}(f.default.Component))||l;j.propTypes=_,j.defaultProps=E,t.default=j},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u,l=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),c=n(1),s=r(c),f=n(5),d=n(32),p=r(d),h=n(6),y=r(h),m=(0,f.autobind)(u=function(e){function t(){return o(this,t),a(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return i(t,e),l(t,[{key:"onLanguageChange",value:function(e){var t=window.location.pathname,n=void 0;n="zh-cn"===e?"en-us":"zh-cn";var r=t.replace(window.rootPath+"/"+n,window.rootPath+"/"+e);p.default.set("docsite_language",e,{expires:365}),window.location=r}},{key:"getLanguage",value:function(){var e=window.location.pathname.replace(window.rootPath||"","").split("/")[1],t=this.props.lang||e||p.default.get("docsite_language")||y.default.defaultLanguage;return"en-us"!==t&&"zh-cn"!==t&&(t=y.default.defaultLanguage),t!==p.default.get("docsite_language")&&p.default.set("docsite_language",t,{expires:365}),t}}]),t}(s.default.Component))||u;t.default=m},,function(e,t,n){"use strict";function r(e,t){var n=e.prototype;for(var r in t)for(var i=t[r],u=0,l=i.length;u<l;u++){var c=i[u];o(n,r,c(n,r,a(n,r)))}return e}t.a=r;var o=Object.defineProperty,a=Object.getOwnPropertyDescriptor},function(e,t,n){"use strict";function r(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}function o(e,t){if("undefined"==typeof WeakMap)throw new Error("Using @autobind on "+t.name+"() requires WeakMap support due to its use of super."+t.name+"()\n      See https://github.com/jayphelps/core-decorators.js/issues/20");d||(d=new WeakMap),!1===d.has(e)&&d.set(e,new WeakMap);var r=d.get(e);return!1===r.has(t)&&r.set(t,n.i(c.a)(t,e)),r.get(t)}function a(e){for(var t=n.i(c.f)(e.prototype),r=n.i(c.g)(t),o=0,a=r.length;o<a;o++){var u=r[o],l=t[u];"function"==typeof l.value&&"constructor"!==u&&s(e.prototype,u,i(e.prototype,u,l))}}function i(e,t,r){var a=r.value,i=r.configurable,u=r.enumerable;if("function"!=typeof a)throw new SyntaxError("@autobind can only be used on functions, not: "+a);var l=e.constructor;return{configurable:i,enumerable:u,get:function(){if(this===e)return a;if(this.constructor!==l&&f(this).constructor===l)return a;if(this.constructor!==l&&t in this.constructor.prototype)return o(this,a);var r=n.i(c.a)(a,this);return s(this,t,{configurable:!0,writable:!0,enumerable:!1,value:r}),r},set:n.i(c.e)(t)}}function u(e){return 1===e.length?a.apply(void 0,r(e)):i.apply(void 0,r(e))}function l(){for(var e=arguments.length,t=Array(e),n=0;n<e;n++)t[n]=arguments[n];return 0===t.length?function(){return u(arguments)}:u(t)}t.a=l;var c=n(0),s=Object.defineProperty,f=Object.getPrototypeOf,d=void 0},function(e,t,n){"use strict";function r(e,t,r,o){var c=u(o,2),s=c[0],f=void 0===s?l:s,d=c[1],p=void 0!==d&&d,h=r.value;if("function"!=typeof h)throw new SyntaxError("Only functions can be debounced");return i({},r,{value:function(){var e=this,r=n.i(a.c)(this),o=r.debounceTimeoutIds,i=o[t],u=p&&!i,l=arguments;clearTimeout(i),o[t]=setTimeout(function(){delete o[t],p||h.apply(e,l)},f),u&&h.apply(this,l)}})}function o(){n.i(a.h)("@debounce is deprecated and will be removed shortly. Use @debounce from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators");for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l=300},function(e,t,n){"use strict";function r(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}function o(e){return Array.isArray(e)?e:Array.from(e)}function a(e,t,a,i){var c=o(i),s=c[0],f=c.slice(1),d=a.configurable,p=a.enumerable,h=a.writable,y=a.get,m=a.set,g=a.value,v=!!y;return{configurable:d,enumerable:p,get:function(){var e=v?y.call(this):g,n=s.call.apply(s,[this,e].concat(r(f)));if(v)return n;var o={configurable:d,enumerable:p};return o.value=n,o.writable=h,l(this,t,o),n},set:v?m:n.i(u.e)()}}function i(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(u.d)(a,t)}t.a=i;var u=n(0),l=Object.defineProperty},function(e,t,n){"use strict";function r(e,t,r,o){var c=u(o,2),s=c[0],f=void 0===s?l:s,d=c[1],p=void 0===d?{}:d;if("function"!=typeof r.value)throw new SyntaxError("Only functions can be marked as deprecated");var h=e.constructor.name+"#"+t;return p.url&&(f+="\n\n    See "+p.url+" for more details.\n\n"),i({},r,{value:function(){return n.i(a.b)("DEPRECATION "+h+": "+f),r.value.apply(this,arguments)}})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l="This function will be removed in future versions."},function(e,t,n){"use strict";function r(e,t,n){return n.enumerable=!0,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(e,t,n){var r=u(e),o=l(r,t);return i({},o,{value:n.value,initializer:n.initializer,get:n.get||o.get,set:n.set||o.set})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=Object.getPrototypeOf,l=Object.getOwnPropertyDescriptor},function(e,t,n){"use strict";function r(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function o(e,t){return t===Object(t)?t:e[t]||(e[t]={})}function a(e,t,n,r,o){var a=t.apply(e,n);return r[o]=a,a}function i(e){var t=void 0,n=void 0;return e.value?(t=e.value,n="value"):e.get?(t=e.get,n="get"):e.set&&(t=e.set,n="set"),{fn:t,wrapKey:n}}function u(e,t,n){var u=i(n),l=u.fn,c=u.wrapKey,f=new WeakMap,d=Object.create(null),p=Object.create(null),h=0;return s({},n,r({},c,function(){for(var e=arguments.length,t=Array(e),n=0;n<e;n++)t[n]=arguments[n];for(var r="0",i=0,u=t.length;i<u;i++){var c=t[i],s=o(p,c),y=f.get(s);void 0===y&&(y=++h,f.set(s,y)),r+=y}return d[r]||a(this,l,arguments,d,r)}))}function l(){n.i(c.h)("@memoize is deprecated and will be removed shortly. Use @memoize from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators");for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(c.d)(u,t)}t.a=l;var c=n(0),s=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e}},function(e,t,n){"use strict";function r(e){return"[object Symbol]"===Object.prototype.toString.call(e)&&"object"===(void 0===e?"undefined":l(e))}function o(e,t){if(r(e)){do{if(t===Object.prototype)return void 0!==t[e];if(t.hasOwnProperty(e))return!0}while(t=s(t));return!1}return e in t}function a(e,t){if(!t.length)throw new SyntaxError("@mixin() class "+e.name+" requires at least one mixin as an argument");for(var r=0,a=t.length;r<a;r++)for(var i=n.i(u.f)(t[r]),l=n.i(u.g)(i),s=0,f=l.length;s<f;s++){var d=l[s];o(d,e.prototype)||c(e.prototype,d,i[d])}}function i(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(u.h)("@mixin is deprecated and will be removed shortly. Use @mixin from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators"),"function"==typeof t[0]?a(t[0],[]):function(e){return a(e,t)}}t.a=i;var u=n(0),l="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},c=Object.defineProperty,s=Object.getPrototypeOf},function(e,t,n){"use strict";function r(e,t,n){return n.configurable=!1,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(e,t,n){return n.enumerable=!1,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function o(e){return e.hasOwnProperty("value")?"data":e.hasOwnProperty("get")||e.hasOwnProperty("set")?"accessor":"data"}function a(e,t,n){n.assert(e.length===t.length)}function i(e,t,n){var r=p(e.value),o=p(t.value);if("undefined"===r&&"undefined"===o&&n.error("descriptor values are both undefined. (class properties are are not currently supported)'"),r!==o){("function"===o&&void 0===r||void 0!==r)&&n.error('value types do not match. {parent} is "'+r+'", {child} is "'+o+'"')}switch(o){case"function":a(e.value,t.value,n);break;default:n.error('Unexpected error. Please file a bug with: {parent} is "'+r+'", {child} is "'+o+'"')}}function u(e,t,n){var r="function"==typeof e.get,o="function"==typeof t.get,i="function"==typeof e.set,u="function"==typeof t.set;(r||o)&&(!r&&i&&n.error("{parent} is setter but {child} is getter"),!o&&u&&n.error("{parent} is getter but {child} is setter"),a(e.get,t.get,n)),(i||u)&&(!i&&r&&n.error("{parent} is getter but {child} is setter"),!u&&o&&n.error("{parent} is setter but {child} is getter"),a(e.set,t.set,n))}function l(e,t,n){var r=o(e),a=o(t);switch(r!==a&&n.error('descriptor types do not match. {parent} is "'+r+'", {child} is "'+a+'"'),a){case"data":i(e,t,n);break;case"accessor":u(e,t,n)}}function c(e,t){for(var n=0,r=g.length;n<r;n++){var o=g[n],a=o(t);if(a in e)return a}return null}function s(e,t,n){n.key=t;var r=Object.getPrototypeOf(e),o=Object.getOwnPropertyDescriptor(r,t),a=new m(r,e,o,n);if(void 0===o){var i=c(r,t),u=i?'\n\n  Did you mean "'+i+'"?':"";a.error("No descriptor matching {child} was found on the prototype chain."+u)}return l(o,n,a),n}function f(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(d.d)(s,t)}t.a=f;var d=n(0),p="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},h=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),y=/^function ([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?(\([^\)]*\))[\s\S]+$/,m=function(){function e(t,n,o,a){r(this,e),this.parentKlass=t,this.childKlass=n,this.parentDescriptor=o,this.childDescriptor=a}return h(e,[{key:"_getTopic",value:function(e){return void 0===e?null:"value"in e?e.value:"get"in e?e.get:"set"in e?e.set:void 0}},{key:"_extractTopicSignature",value:function(e){switch(void 0===e?"undefined":p(e)){case"function":return this._extractFunctionSignature(e);default:return this.key}}},{key:"_extractFunctionSignature",value:function(e){var t=this;return e.toString().replace(y,function(e){return(arguments.length>1&&void 0!==arguments[1]?arguments[1]:t.key)+arguments[2]})}},{key:"key",get:function(){return this.childDescriptor.key}},{key:"parentNotation",get:function(){return this.parentKlass.constructor.name+"#"+this.parentPropertySignature}},{key:"childNotation",get:function(){return this.childKlass.constructor.name+"#"+this.childPropertySignature}},{key:"parentTopic",get:function(){return this._getTopic(this.parentDescriptor)}},{key:"childTopic",get:function(){return this._getTopic(this.childDescriptor)}},{key:"parentPropertySignature",get:function(){return this._extractTopicSignature(this.parentTopic)}},{key:"childPropertySignature",get:function(){return this._extractTopicSignature(this.childTopic)}}]),h(e,[{key:"assert",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"";!0!==e&&this.error("{child} does not properly override {parent}"+t)}},{key:"error",value:function(e){var t=this;throw e=e.replace("{parent}",function(e){return t.parentNotation}).replace("{child}",function(e){return t.childNotation}),new SyntaxError(e)}}]),e}(),g=[function(e){return e.toLowerCase()},function(e){return e.toUpperCase()},function(e){return e+"s"},function(e){return e.slice(0,-1)},function(e){return e.slice(1,e.length)}]},function(e,t,n){"use strict";function r(e,t,r,c){var s=u(c,3),f=s[0],d=void 0===f?null:f,p=s[1],h=void 0!==p&&p,y=s[2],m=void 0===y?l:y;if(!o.__enabled)return o.__warned||(m.warn("console.profile is not supported. All @profile decorators are disabled."),o.__warned=!0),r;var g=r.value;if(null===d&&(d=e.constructor.name+"."+t),"function"!=typeof g)throw new SyntaxError("@profile can only be used on functions, not: "+g);return i({},r,{value:function(){var e=Date.now(),t=n.i(a.c)(this);(!0===h&&!t.profileLastRan||!1===h||"number"==typeof h&&e-t.profileLastRan>h||"function"==typeof h&&h.apply(this,arguments))&&(m.profile(d),t.profileLastRan=e);try{return g.apply(this,arguments)}finally{m.profileEnd(d)}}})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l=(console,{profile:console.profile?n.i(a.a)(console.profile,console):function(){},profileEnd:console.profileEnd?n.i(a.a)(console.profileEnd,console):function(){},warn:a.b});o.__enabled=!!console.profile,o.__warned=!1},function(e,t,n){"use strict";function r(e,t,n){return n.writable=!1,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(){}function o(e,t,n){if("object"===("undefined"==typeof console?"undefined":c(console))){var o=console.warn;console.warn=r;var a=t.apply(e,n);return console.warn=o,a}return t.apply(e,n)}function a(e,t,n){return l({},n,{value:function(){return o(this,n.value,arguments)}})}function i(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(u.d)(a,t)}t.a=i;var u=n(0),l=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},c="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e}},function(e,t,n){"use strict";function r(e,t,r,o){var c=u(o,2),s=c[0],f=void 0===s?l:s,d=c[1],p=void 0===d?{}:d,h=r.value;if("function"!=typeof h)throw new SyntaxError("Only functions can be throttled");return!1!==p.leading&&(p.leading=!0),!1!==p.trailing&&(p.trailing=!0),i({},r,{value:function(){var e=this,r=n.i(a.c)(this),o=r.throttleTimeoutIds,i=r.throttlePreviousTimestamps,u=o[t],l=i[t]||0,c=Date.now();p.trailing&&(r.throttleTrailingArgs=arguments),l||!1!==p.leading||(l=c);var s=f-(c-l);s<=0?(clearTimeout(u),delete o[t],i[t]=c,h.apply(this,arguments)):!u&&p.trailing&&(o[t]=setTimeout(function(){i[t]=!1===p.leading?0:Date.now(),delete o[t],h.apply(e,r.throttleTrailingArgs),r.throttleTrailingArgs=null},s))}})}function o(){n.i(a.h)("@throttle is deprecated and will be removed shortly. Use @throttle from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators");for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l=300},function(e,t,n){"use strict";function r(e,t,n,r){var o=u(r,2),a=o[0],l=void 0===a?null:a,f=o[1],d=void 0===f?c:f,p=n.value;if(null===l&&(l=e.constructor.name+"."+t),"function"!=typeof p)throw new SyntaxError("@time can only be used on functions, not: "+p);return i({},n,{value:function(){var e=l+"-"+s;s++,d.time(e);try{return p.apply(this,arguments)}finally{d.timeEnd(e)}}})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l={},c={time:console.time?console.time.bind(console):function(e){l[e]=new Date},timeEnd:console.timeEnd?console.timeEnd.bind(console):function(e){var t=new Date,n=t-l[e];delete l[e],console.log(e+": "+n+"ms")}},s=0},function(e,t){},function(e,t){},function(e,t,n){var r,o;!function(a){var i=!1;if(r=a,void 0!==(o="function"==typeof r?r.call(t,n,t,e):r)&&(e.exports=o),i=!0,e.exports=a(),i=!0,!i){var u=window.Cookies,l=window.Cookies=a();l.noConflict=function(){return window.Cookies=u,l}}}(function(){function e(){for(var e=0,t={};e<arguments.length;e++){var n=arguments[e];for(var r in n)t[r]=n[r]}return t}function t(n){function r(t,o,a){var i;if("undefined"!=typeof document){if(arguments.length>1){if(a=e({path:"/"},r.defaults,a),"number"==typeof a.expires){var u=new Date;u.setMilliseconds(u.getMilliseconds()+864e5*a.expires),a.expires=u}a.expires=a.expires?a.expires.toUTCString():"";try{i=JSON.stringify(o),/^[\{\[]/.test(i)&&(o=i)}catch(e){}o=n.write?n.write(o,t):encodeURIComponent(String(o)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g,decodeURIComponent),t=encodeURIComponent(String(t)),t=t.replace(/%(23|24|26|2B|5E|60|7C)/g,decodeURIComponent),t=t.replace(/[\(\)]/g,escape);var l="";for(var c in a)a[c]&&(l+="; "+c,!0!==a[c]&&(l+="="+a[c]));return document.cookie=t+"="+o+l}t||(i={});for(var s=document.cookie?document.cookie.split("; "):[],f=/(%[0-9A-Z]{2})+/g,d=0;d<s.length;d++){var p=s[d].split("="),h=p.slice(1).join("=");this.json||'"'!==h.charAt(0)||(h=h.slice(1,-1));try{var y=p[0].replace(f,decodeURIComponent);if(h=n.read?n.read(h,y):n(h,y)||h.replace(f,decodeURIComponent),this.json)try{h=JSON.parse(h)}catch(e){}if(t===y){i=h;break}t||(i[y]=h)}catch(e){}}return i}}return r.set=r,r.get=function(e){return r.call(r,e)},r.getJSON=function(){return r.apply({json:!0},[].slice.call(arguments))},r.defaults={},r.remove=function(t,n){r(t,"",e(n,{expires:-1}))},r.withConverter=t,r}return t(function(){})})},function(e,t,n){"use strict";function r(){}function o(){}var a=n(34);o.resetWarningCache=r,e.exports=function(){function e(e,t,n,r,o,i){if(i!==a){var u=new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");throw u.name="Invariant Violation",u}}function t(){return e}e.isRequired=e;var n={array:e,bool:e,func:e,number:e,object:e,string:e,symbol:e,any:e,arrayOf:t,element:e,elementType:e,instanceOf:t,node:e,objectOf:t,oneOf:t,oneOfType:t,shape:t,exact:t,checkPropTypes:o,resetWarningCache:r};return n.PropTypes=n,n}},function(e,t,n){"use strict";e.exports="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"},,function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var o=n(1),a=r(o),i=n(3),u=r(i),l=n(7),c=r(l),s=n(2);n(41);var f={text:u.default.string.isRequired,img:u.default.string.isRequired},d=function(e){var t=e.text,n=e.img,r=(0,c.default)({bar:!0});return a.default.createElement("div",{className:r},a.default.createElement("div",{className:"bar-body"},a.default.createElement("img",{src:(0,s.getLink)(n),className:"front-img"}),a.default.createElement("span",null,t),a.default.createElement("img",{src:(0,s.getLink)(n),className:"back-img"})))};d.propTypes=f,t.default=d},,,,,function(e,t){},,,,,,,,,,,,,,,,function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default={"en-us":{barText:"Blog",postsTitle:"All posts",list:[{title:"Java new feature",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java new feature",link:"/en-us/blog/java/feature.html"},{title:"Java Class loading mechanism",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java Class loading mechanism",link:"/en-us/blog/java/load-class.html"},{title:"ORM merit and demerit",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"ORM,Orm merit and demerit",link:"/en-us/blog/java/orm.html"},{title:"Python new feature",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python new feature",link:"/en-us/blog/python/feature.html"},{title:"Python character operation",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python character operation",link:"/en-us/blog/python/str_joint.html"},{title:"Python syntax rule",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python syntax rule",link:"/en-us/blog/python/syntax_rule.html"},{title:"Data Split",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"Data Split",link:"/en-us/blog/sql/data_split.html"}]},"zh-cn":{barText:"博客",postsTitle:"所有文章",list:[{title:"Java 新特性",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java 新特性",link:"/zh-cn/blog/java/feature.html"},{title:"Java 类加载机制",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java 类加载机制",link:"/zh-cn/blog/java/load-class.html"},{title:"Orm的优缺点",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Orm的优缺点",link:"/zh-cn/blog/java/orm.html"},{title:"Python 新特性",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python 新特性",link:"/zh-cn/blog/python/feature.html"},{title:"Python 字符操作",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python 字符操作",link:"/zh-cn/blog/python/str_joint.html"},{title:"Python 语法技巧",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python 语法技巧",link:"/zh-cn/blog/python/syntax_rule.html"},{title:"数据库拆分",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"Database Split",link:"/zh-cn/blog/sql/data_split.html"}]}}},,,,,function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u,l=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),c=n(1),s=r(c),f=n(3),d=r(f),p=n(5),h=n(7),y=r(h),m=n(2);n(83);var g={pageSize:d.default.number},v={pageSize:5},b=(0,p.autobind)(u=function(e){function t(e){o(this,t);var n=a(this,(t.__proto__||Object.getPrototypeOf(t)).call(this,e));return n.container=null,n.state={page:0,pageWidth:0},n}return i(t,e),l(t,[{key:"componentDidMount",value:function(){var e=this,t=this.container.getBoundingClientRect().width;this.setState({pageWidth:t}),this.throttleAdjust=(0,m.throttle)(function(){e.setState({pageWidth:e.container.getBoundingClientRect().width})},200),window.addEventListener("resize",this.throttleAdjust)}},{key:"componentWillUnmount",value:function(){window.removeEventListener("resize",this.throttleAdjust)}},{key:"changePage",value:function(e){this.setState({page:e})}},{key:"renderSliderList",value:function(){for(var e=this.props,t=e.children,n=e.pageSize,r=this.state,o=r.page,a=r.pageWidth,i=[],u=s.default.Children.count(t),l=Math.ceil(u/n),c=0;c<l;c++)i.push(Array.from(t).slice(c*n,(c+1)*n));return s.default.createElement("div",{className:"slider-list",style:{transform:"translateX(-"+o*a+"px)",transition:"transform 500ms ease",width:l*a}},i.map(function(e,t){return s.default.createElement("div",{className:"slider-page",style:{width:a},key:t},e.map(function(e,t){return s.default.createElement("div",{className:"slider-item",key:t},e)}))}))}},{key:"renderControl",value:function(){var e=this.props,t=e.children,n=e.pageSize,r=this.state.page,o=s.default.Children.count(t),a=Math.ceil(o/n);return s.default.createElement("div",{className:"slider-control"},s.default.createElement("img",{className:(0,y.default)({"slider-control-prev":!0,"slider-control-prev-hidden":0===r}),src:(0,m.getLink)("/img/system/prev.png"),onClick:this.changePage.bind(this,r-1)}),s.default.createElement("img",{className:(0,y.default)({"slider-control-next":!0,"slider-control-next-hidden":r===a-1}),src:(0,m.getLink)("/img/system/next.png"),onClick:this.changePage.bind(this,r+1)}))}},{key:"render",value:function(){var e=this;return s.default.createElement("div",{className:"page-slider",ref:function(t){e.container=t}},this.renderSliderList(),this.renderControl())}}]),t}(s.default.Component))||u;b.propTypes=g,b.defaultProps=v,t.default=b},,,function(e,t,n){"use strict";function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function o(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var i,u=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),l=n(1),c=function(e){return e&&e.__esModule?e:{default:e}}(l),s=n(5),f=n(2);n(86);var d=(0,s.autobind)(i=function(e){function t(e){r(this,t);var n=o(this,(t.__proto__||Object.getPrototypeOf(t)).call(this,e));return n.state={isHovered:!1},n}return a(t,e),u(t,[{key:"onMouseOver",value:function(){this.setState({isHovered:!0})}},{key:"onMouseOut",value:function(){this.setState({isHovered:!1})}},{key:"render",value:function(){var e=this.props.dataSource,t=e.link,n=e.target,r=e.title,o=e.author,a=e.companyIcon,i=e.companyIconHover,u=e.dateStr,l=e.desc,s=this.state.isHovered;return c.default.createElement("a",{href:(0,f.getLink)(t),target:n||"_self",className:"blog-item",onMouseOver:this.onMouseOver,onMouseOut:this.onMouseOut},c.default.createElement("div",{className:"title"},c.default.createElement("img",{src:s?(0,f.getLink)("/img/system/docs_hover.png"):(0,f.getLink)("/img/system/docs_normal.png")}),c.default.createElement("span",null,r)),c.default.createElement("div",{className:"brief-info"},c.default.createElement("span",{className:"author"},o),a?c.default.createElement("img",{src:s?(0,f.getLink)(i):(0,f.getLink)(a)}):null,c.default.createElement("span",{className:"date"},u)),c.default.createElement("p",null,l))}}]),t}(c.default.Component))||i;t.default=d},,,,,,,function(e,t){},,,,,,function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),l=n(1),c=r(l),s=n(4),f=r(s),d=n(11),p=r(d),h=n(10),y=r(h),m=n(36),g=r(m),v=n(62),b=r(v),w=n(65),O=r(w),k=n(9),_=r(k),E=n(57),j=r(E),S=n(2);n(72);var P=function(e){function t(){return o(this,t),a(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return i(t,e),u(t,[{key:"render",value:function(){var e=this.getLanguage(),t=j.default[e],n=t.list;return c.default.createElement("div",{className:"blog-list-page"},c.default.createElement(y.default,{type:"normal",currentKey:"blog",logo:"/img/dubbo_colorful.png",language:e,onLanguageChange:this.onLanguageChange}),c.default.createElement(g.default,{img:"/img/system/blog.png",text:t.barText}),c.default.createElement("section",{className:"blog-container"},c.default.createElement("div",{className:"col col-18 left-part"},c.default.createElement(b.default,{pageSize:5},n.map(function(e,t){return c.default.createElement(O.default,{key:t,dataSource:e})}))),c.default.createElement("div",{className:"col col-6 right-part"},c.default.createElement("h4",null,t.postsTitle),c.default.createElement("ul",null,n.map(function(e,t){return c.default.createElement("li",{key:t},c.default.createElement("a",{href:(0,S.getLink)(e.link),target:e.target||"_self"},c.default.createElement("span",null,e.dateStr,"  "),c.default.createElement("span",null,e.title)))})))),c.default.createElement(_.default,{logo:"/img/dubbo_gray.png",language:e}))}}]),t}(p.default);document.getElementById("root")&&f.default.render(c.default.createElement(P,null),document.getElementById("root")),t.default=P},,,,,function(e,t){},,,function(e,t){}]);
\ No newline at end of file
+!function(){"use strict";function n(){for(var e=[],t=0;t<arguments.length;t++){var r=arguments[t];if(r){var o=typeof r;if("string"===o||"number"===o)e.push(r);else if(Array.isArray(r)&&r.length){var i=n.apply(null,r);i&&e.push(i)}else if("object"===o)for(var u in r)a.call(r,u)&&r[u]&&e.push(u)}}return e.join(" ")}var a={}.hasOwnProperty;void 0!==e&&e.exports?(n.default=n,e.exports=n):(r=[],void 0!==(o=function(){return n}.apply(t,r))&&(e.exports=o))}()},function(e,t,n){"use strict";function r(e,t,r){var o=r.configurable,u=r.enumerable,l=r.initializer,c=r.value;return{configurable:o,enumerable:u,get:function(){if(this!==e){var n=l?l.call(this):c;return i(this,t,{configurable:o,enumerable:u,writable:!0,value:n}),n}},set:n.i(a.e)(t)}}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.defineProperty},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),l=n(1),c=r(l),s=n(3),f=r(s),d=n(6),p=r(d),h=n(2);n(30);var y={logo:f.default.string.isRequired,language:f.default.oneOf(["zh-cn","en-us"])},g=function(e){function t(){return o(this,t),a(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return i(t,e),u(t,[{key:"render",value:function(){var e=this.props,t=e.logo,n=e.language,r=p.default[n];return c.default.createElement("footer",{className:"footer-container"},c.default.createElement("div",{className:"footer-body"},c.default.createElement("img",{src:(0,h.getLink)(t)}),c.default.createElement("div",{className:"cols-container"},c.default.createElement("div",{className:"col col-12"},c.default.createElement("h3",null,r.disclaimer.title),c.default.createElement("p",null,r.disclaimer.content)),c.default.createElement("div",{className:"col col-6"},c.default.createElement("dl",null,c.default.createElement("dt",null,r.documentation.title),r.documentation.list.map(function(e,t){return c.default.createElement("dd",{key:t},c.default.createElement("a",{href:(0,h.getLink)(e.link),target:e.target||"_self"},e.text))}))),c.default.createElement("div",{className:"col col-6"},c.default.createElement("dl",null,c.default.createElement("dt",null,r.resources.title),r.resources.list.map(function(e,t){return c.default.createElement("dd",{key:t},c.default.createElement("a",{href:(0,h.getLink)(e.link),target:e.target||"_self"},e.text))})))),c.default.createElement("div",{className:"copyright"},c.default.createElement("span",null,r.copyright))))}}]),t}(c.default.Component);g.propTypes=y,t.default=g},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function a(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function i(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function u(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var l,c=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),s=n(1),f=r(s),d=n(3),p=r(d),h=n(7),y=r(h),g=n(5),m=n(6),v=r(m),b=n(2);n(31);var w=[{text:"中",value:"en-us"},{text:"En",value:"zh-cn"}],O={baidu:{logo:"https://img.alicdn.com/tfs/TB1n6DQayLaK1RjSZFxXXamPFXa-300-300.png",url:"https://www.baidu.com/s?wd="},google:{logo:"https://img.alicdn.com/tfs/TB1REfuaCzqK1RjSZFjXXblCFXa-300-300.jpg",url:"https://www.google.com/search?q="}},k=function(){},_={currentKey:p.default.string,logo:p.default.string.isRequired,type:p.default.oneOf(["primary","normal"]),language:p.default.oneOf(["en-us","zh-cn"]),onLanguageChange:p.default.func},E={type:"primary",language:"en-us",onLanguageChange:k},j=(0,g.autobind)(l=function(e){function t(e){a(this,t);var n=i(this,(t.__proto__||Object.getPrototypeOf(t)).call(this,e));return n.state={menuBodyVisible:!1,language:e.language,search:v.default.defaultSearch,searchValue:"",inputVisible:!1},n}return u(t,e),c(t,[{key:"componentWillReceiveProps",value:function(e){this.setState({language:e.language})}},{key:"toggleMenu",value:function(){this.setState({menuBodyVisible:!this.state.menuBodyVisible})}},{key:"switchLang",value:function(){var e=void 0;e="zh-cn"===this.state.language?"en-us":"zh-cn",this.setState({language:e}),this.props.onLanguageChange(e)}},{key:"switchSearch",value:function(){var e=void 0;e="baidu"===this.state.search?"google":"baidu",this.setState({search:e})}},{key:"toggleSearch",value:function(){this.setState({searchVisible:!this.state.searchVisible})}},{key:"onInputChange",value:function(e){this.setState({searchValue:e.target.value})}},{key:"goSearch",value:function(){var e=this.state,t=e.search,n=e.searchValue;window.open(""+O[t].url+window.encodeURIComponent(n+" site:"+v.default.domain))}},{key:"onKeyDown",value:function(e){13===e.keyCode&&this.goSearch()}},{key:"render",value:function(){var e=this.props,t=e.type,n=e.logo,r=e.onLanguageChange,a=e.currentKey,i=this.state,u=i.menuBodyVisible,l=i.language,c=i.search,s=i.searchVisible;return f.default.createElement("header",{className:(0,y.default)(o({"header-container":!0},"header-container-"+t,!0))},f.default.createElement("div",{className:"header-body"},f.default.createElement("a",{href:(0,b.getLink)("/"+l+"/index.html")},f.default.createElement("img",{className:"logo",alt:v.default.name,title:v.default.name,src:(0,b.getLink)(n)})),v.default.defaultSearch?f.default.createElement("div",{className:(0,y.default)(o({search:!0},"search-"+t,!0))},f.default.createElement("span",{className:"icon-search",onClick:this.toggleSearch}),s?f.default.createElement("div",{className:"search-input"},f.default.createElement("img",{src:O[c].logo,onClick:this.switchSearch}),f.default.createElement("input",{autoFocus:!0,onChange:this.onInputChange,onKeyDown:this.onKeyDown})):null):null,r!==k?f.default.createElement("span",{className:(0,y.default)(o({"language-switch":!0},"language-switch-"+t,!0)),onClick:this.switchLang},w.find(function(e){return e.value===l}).text):null,f.default.createElement("div",{className:(0,y.default)({"header-menu":!0,"header-menu-open":u})},f.default.createElement("img",{className:"header-menu-toggle",onClick:this.toggleMenu,src:"primary"===t?(0,b.getLink)("/img/system/menu_white.png"):(0,b.getLink)("/img/system/menu_gray.png")}),f.default.createElement("ul",null,v.default[l].pageMenu.map(function(e){var n;return f.default.createElement("li",{className:(0,y.default)((n={"menu-item":!0},o(n,"menu-item-"+t,!0),o(n,"menu-item-"+t+"-active",a===e.key),n)),key:e.key},f.default.createElement("a",{href:(0,b.getLink)(e.link),target:e.target||"_self"},e.text))})))))}}]),t}(f.default.Component))||l;j.propTypes=_,j.defaultProps=E,t.default=j},function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u,l=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),c=n(1),s=r(c),f=n(5),d=n(32),p=r(d),h=n(6),y=r(h),g=(0,f.autobind)(u=function(e){function t(){return o(this,t),a(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return i(t,e),l(t,[{key:"onLanguageChange",value:function(e){var t=window.location.pathname,n=void 0;n="zh-cn"===e?"en-us":"zh-cn";var r=t.replace(window.rootPath+"/"+n,window.rootPath+"/"+e);p.default.set("docsite_language",e,{expires:365}),window.location=r}},{key:"getLanguage",value:function(){var e=window.location.pathname.replace(window.rootPath||"","").split("/")[1],t=this.props.lang||e||p.default.get("docsite_language")||y.default.defaultLanguage;return"en-us"!==t&&"zh-cn"!==t&&(t=y.default.defaultLanguage),t!==p.default.get("docsite_language")&&p.default.set("docsite_language",t,{expires:365}),t}}]),t}(s.default.Component))||u;t.default=g},,function(e,t,n){"use strict";function r(e,t){var n=e.prototype;for(var r in t)for(var i=t[r],u=0,l=i.length;u<l;u++){var c=i[u];o(n,r,c(n,r,a(n,r)))}return e}t.a=r;var o=Object.defineProperty,a=Object.getOwnPropertyDescriptor},function(e,t,n){"use strict";function r(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}function o(e,t){if("undefined"==typeof WeakMap)throw new Error("Using @autobind on "+t.name+"() requires WeakMap support due to its use of super."+t.name+"()\n      See https://github.com/jayphelps/core-decorators.js/issues/20");d||(d=new WeakMap),!1===d.has(e)&&d.set(e,new WeakMap);var r=d.get(e);return!1===r.has(t)&&r.set(t,n.i(c.a)(t,e)),r.get(t)}function a(e){for(var t=n.i(c.f)(e.prototype),r=n.i(c.g)(t),o=0,a=r.length;o<a;o++){var u=r[o],l=t[u];"function"==typeof l.value&&"constructor"!==u&&s(e.prototype,u,i(e.prototype,u,l))}}function i(e,t,r){var a=r.value,i=r.configurable,u=r.enumerable;if("function"!=typeof a)throw new SyntaxError("@autobind can only be used on functions, not: "+a);var l=e.constructor;return{configurable:i,enumerable:u,get:function(){if(this===e)return a;if(this.constructor!==l&&f(this).constructor===l)return a;if(this.constructor!==l&&t in this.constructor.prototype)return o(this,a);var r=n.i(c.a)(a,this);return s(this,t,{configurable:!0,writable:!0,enumerable:!1,value:r}),r},set:n.i(c.e)(t)}}function u(e){return 1===e.length?a.apply(void 0,r(e)):i.apply(void 0,r(e))}function l(){for(var e=arguments.length,t=Array(e),n=0;n<e;n++)t[n]=arguments[n];return 0===t.length?function(){return u(arguments)}:u(t)}t.a=l;var c=n(0),s=Object.defineProperty,f=Object.getPrototypeOf,d=void 0},function(e,t,n){"use strict";function r(e,t,r,o){var c=u(o,2),s=c[0],f=void 0===s?l:s,d=c[1],p=void 0!==d&&d,h=r.value;if("function"!=typeof h)throw new SyntaxError("Only functions can be debounced");return i({},r,{value:function(){var e=this,r=n.i(a.c)(this),o=r.debounceTimeoutIds,i=o[t],u=p&&!i,l=arguments;clearTimeout(i),o[t]=setTimeout(function(){delete o[t],p||h.apply(e,l)},f),u&&h.apply(this,l)}})}function o(){n.i(a.h)("@debounce is deprecated and will be removed shortly. Use @debounce from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators");for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l=300},function(e,t,n){"use strict";function r(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}function o(e){return Array.isArray(e)?e:Array.from(e)}function a(e,t,a,i){var c=o(i),s=c[0],f=c.slice(1),d=a.configurable,p=a.enumerable,h=a.writable,y=a.get,g=a.set,m=a.value,v=!!y;return{configurable:d,enumerable:p,get:function(){var e=v?y.call(this):m,n=s.call.apply(s,[this,e].concat(r(f)));if(v)return n;var o={configurable:d,enumerable:p};return o.value=n,o.writable=h,l(this,t,o),n},set:v?g:n.i(u.e)()}}function i(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(u.d)(a,t)}t.a=i;var u=n(0),l=Object.defineProperty},function(e,t,n){"use strict";function r(e,t,r,o){var c=u(o,2),s=c[0],f=void 0===s?l:s,d=c[1],p=void 0===d?{}:d;if("function"!=typeof r.value)throw new SyntaxError("Only functions can be marked as deprecated");var h=e.constructor.name+"#"+t;return p.url&&(f+="\n\n    See "+p.url+" for more details.\n\n"),i({},r,{value:function(){return n.i(a.b)("DEPRECATION "+h+": "+f),r.value.apply(this,arguments)}})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l="This function will be removed in future versions."},function(e,t,n){"use strict";function r(e,t,n){return n.enumerable=!0,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(e,t,n){var r=u(e),o=l(r,t);return i({},o,{value:n.value,initializer:n.initializer,get:n.get||o.get,set:n.set||o.set})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=Object.getPrototypeOf,l=Object.getOwnPropertyDescriptor},function(e,t,n){"use strict";function r(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function o(e,t){return t===Object(t)?t:e[t]||(e[t]={})}function a(e,t,n,r,o){var a=t.apply(e,n);return r[o]=a,a}function i(e){var t=void 0,n=void 0;return e.value?(t=e.value,n="value"):e.get?(t=e.get,n="get"):e.set&&(t=e.set,n="set"),{fn:t,wrapKey:n}}function u(e,t,n){var u=i(n),l=u.fn,c=u.wrapKey,f=new WeakMap,d=Object.create(null),p=Object.create(null),h=0;return s({},n,r({},c,function(){for(var e=arguments.length,t=Array(e),n=0;n<e;n++)t[n]=arguments[n];for(var r="0",i=0,u=t.length;i<u;i++){var c=t[i],s=o(p,c),y=f.get(s);void 0===y&&(y=++h,f.set(s,y)),r+=y}return d[r]||a(this,l,arguments,d,r)}))}function l(){n.i(c.h)("@memoize is deprecated and will be removed shortly. Use @memoize from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators");for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(c.d)(u,t)}t.a=l;var c=n(0),s=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e}},function(e,t,n){"use strict";function r(e){return"[object Symbol]"===Object.prototype.toString.call(e)&&"object"===(void 0===e?"undefined":l(e))}function o(e,t){if(r(e)){do{if(t===Object.prototype)return void 0!==t[e];if(t.hasOwnProperty(e))return!0}while(t=s(t));return!1}return e in t}function a(e,t){if(!t.length)throw new SyntaxError("@mixin() class "+e.name+" requires at least one mixin as an argument");for(var r=0,a=t.length;r<a;r++)for(var i=n.i(u.f)(t[r]),l=n.i(u.g)(i),s=0,f=l.length;s<f;s++){var d=l[s];o(d,e.prototype)||c(e.prototype,d,i[d])}}function i(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(u.h)("@mixin is deprecated and will be removed shortly. Use @mixin from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators"),"function"==typeof t[0]?a(t[0],[]):function(e){return a(e,t)}}t.a=i;var u=n(0),l="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},c=Object.defineProperty,s=Object.getPrototypeOf},function(e,t,n){"use strict";function r(e,t,n){return n.configurable=!1,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(e,t,n){return n.enumerable=!1,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function o(e){return e.hasOwnProperty("value")?"data":e.hasOwnProperty("get")||e.hasOwnProperty("set")?"accessor":"data"}function a(e,t,n){n.assert(e.length===t.length)}function i(e,t,n){var r=p(e.value),o=p(t.value);if("undefined"===r&&"undefined"===o&&n.error("descriptor values are both undefined. (class properties are are not currently supported)'"),r!==o){("function"===o&&void 0===r||void 0!==r)&&n.error('value types do not match. {parent} is "'+r+'", {child} is "'+o+'"')}switch(o){case"function":a(e.value,t.value,n);break;default:n.error('Unexpected error. Please file a bug with: {parent} is "'+r+'", {child} is "'+o+'"')}}function u(e,t,n){var r="function"==typeof e.get,o="function"==typeof t.get,i="function"==typeof e.set,u="function"==typeof t.set;(r||o)&&(!r&&i&&n.error("{parent} is setter but {child} is getter"),!o&&u&&n.error("{parent} is getter but {child} is setter"),a(e.get,t.get,n)),(i||u)&&(!i&&r&&n.error("{parent} is getter but {child} is setter"),!u&&o&&n.error("{parent} is setter but {child} is getter"),a(e.set,t.set,n))}function l(e,t,n){var r=o(e),a=o(t);switch(r!==a&&n.error('descriptor types do not match. {parent} is "'+r+'", {child} is "'+a+'"'),a){case"data":i(e,t,n);break;case"accessor":u(e,t,n)}}function c(e,t){for(var n=0,r=m.length;n<r;n++){var o=m[n],a=o(t);if(a in e)return a}return null}function s(e,t,n){n.key=t;var r=Object.getPrototypeOf(e),o=Object.getOwnPropertyDescriptor(r,t),a=new g(r,e,o,n);if(void 0===o){var i=c(r,t),u=i?'\n\n  Did you mean "'+i+'"?':"";a.error("No descriptor matching {child} was found on the prototype chain."+u)}return l(o,n,a),n}function f(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(d.d)(s,t)}t.a=f;var d=n(0),p="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},h=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),y=/^function ([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?(\([^\)]*\))[\s\S]+$/,g=function(){function e(t,n,o,a){r(this,e),this.parentKlass=t,this.childKlass=n,this.parentDescriptor=o,this.childDescriptor=a}return h(e,[{key:"_getTopic",value:function(e){return void 0===e?null:"value"in e?e.value:"get"in e?e.get:"set"in e?e.set:void 0}},{key:"_extractTopicSignature",value:function(e){switch(void 0===e?"undefined":p(e)){case"function":return this._extractFunctionSignature(e);default:return this.key}}},{key:"_extractFunctionSignature",value:function(e){var t=this;return e.toString().replace(y,function(e){return(arguments.length>1&&void 0!==arguments[1]?arguments[1]:t.key)+arguments[2]})}},{key:"key",get:function(){return this.childDescriptor.key}},{key:"parentNotation",get:function(){return this.parentKlass.constructor.name+"#"+this.parentPropertySignature}},{key:"childNotation",get:function(){return this.childKlass.constructor.name+"#"+this.childPropertySignature}},{key:"parentTopic",get:function(){return this._getTopic(this.parentDescriptor)}},{key:"childTopic",get:function(){return this._getTopic(this.childDescriptor)}},{key:"parentPropertySignature",get:function(){return this._extractTopicSignature(this.parentTopic)}},{key:"childPropertySignature",get:function(){return this._extractTopicSignature(this.childTopic)}}]),h(e,[{key:"assert",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"";!0!==e&&this.error("{child} does not properly override {parent}"+t)}},{key:"error",value:function(e){var t=this;throw e=e.replace("{parent}",function(e){return t.parentNotation}).replace("{child}",function(e){return t.childNotation}),new SyntaxError(e)}}]),e}(),m=[function(e){return e.toLowerCase()},function(e){return e.toUpperCase()},function(e){return e+"s"},function(e){return e.slice(0,-1)},function(e){return e.slice(1,e.length)}]},function(e,t,n){"use strict";function r(e,t,r,c){var s=u(c,3),f=s[0],d=void 0===f?null:f,p=s[1],h=void 0!==p&&p,y=s[2],g=void 0===y?l:y;if(!o.__enabled)return o.__warned||(g.warn("console.profile is not supported. All @profile decorators are disabled."),o.__warned=!0),r;var m=r.value;if(null===d&&(d=e.constructor.name+"."+t),"function"!=typeof m)throw new SyntaxError("@profile can only be used on functions, not: "+m);return i({},r,{value:function(){var e=Date.now(),t=n.i(a.c)(this);(!0===h&&!t.profileLastRan||!1===h||"number"==typeof h&&e-t.profileLastRan>h||"function"==typeof h&&h.apply(this,arguments))&&(g.profile(d),t.profileLastRan=e);try{return m.apply(this,arguments)}finally{g.profileEnd(d)}}})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l=(console,{profile:console.profile?n.i(a.a)(console.profile,console):function(){},profileEnd:console.profileEnd?n.i(a.a)(console.profileEnd,console):function(){},warn:a.b});o.__enabled=!!console.profile,o.__warned=!1},function(e,t,n){"use strict";function r(e,t,n){return n.writable=!1,n}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0)},function(e,t,n){"use strict";function r(){}function o(e,t,n){if("object"===("undefined"==typeof console?"undefined":c(console))){var o=console.warn;console.warn=r;var a=t.apply(e,n);return console.warn=o,a}return t.apply(e,n)}function a(e,t,n){return l({},n,{value:function(){return o(this,n.value,arguments)}})}function i(){for(var e=arguments.length,t=Array(e),r=0;r<e;r++)t[r]=arguments[r];return n.i(u.d)(a,t)}t.a=i;var u=n(0),l=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},c="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e}},function(e,t,n){"use strict";function r(e,t,r,o){var c=u(o,2),s=c[0],f=void 0===s?l:s,d=c[1],p=void 0===d?{}:d,h=r.value;if("function"!=typeof h)throw new SyntaxError("Only functions can be throttled");return!1!==p.leading&&(p.leading=!0),!1!==p.trailing&&(p.trailing=!0),i({},r,{value:function(){var e=this,r=n.i(a.c)(this),o=r.throttleTimeoutIds,i=r.throttlePreviousTimestamps,u=o[t],l=i[t]||0,c=Date.now();p.trailing&&(r.throttleTrailingArgs=arguments),l||!1!==p.leading||(l=c);var s=f-(c-l);s<=0?(clearTimeout(u),delete o[t],i[t]=c,h.apply(this,arguments)):!u&&p.trailing&&(o[t]=setTimeout(function(){i[t]=!1===p.leading?0:Date.now(),delete o[t],h.apply(e,r.throttleTrailingArgs),r.throttleTrailingArgs=null},s))}})}function o(){n.i(a.h)("@throttle is deprecated and will be removed shortly. Use @throttle from lodash-decorators.\n\n  https://www.npmjs.com/package/lodash-decorators");for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l=300},function(e,t,n){"use strict";function r(e,t,n,r){var o=u(r,2),a=o[0],l=void 0===a?null:a,f=o[1],d=void 0===f?c:f,p=n.value;if(null===l&&(l=e.constructor.name+"."+t),"function"!=typeof p)throw new SyntaxError("@time can only be used on functions, not: "+p);return i({},n,{value:function(){var e=l+"-"+s;s++,d.time(e);try{return p.apply(this,arguments)}finally{d.timeEnd(e)}}})}function o(){for(var e=arguments.length,t=Array(e),o=0;o<e;o++)t[o]=arguments[o];return n.i(a.d)(r,t)}t.a=o;var a=n(0),i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},u=function(){function e(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}return function(t,n){if(Array.isArray(t))return t;if(Symbol.iterator in Object(t))return e(t,n);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),l={},c={time:console.time?console.time.bind(console):function(e){l[e]=new Date},timeEnd:console.timeEnd?console.timeEnd.bind(console):function(e){var t=new Date,n=t-l[e];delete l[e],console.log(e+": "+n+"ms")}},s=0},function(e,t){},function(e,t){},function(e,t,n){var r,o;!function(a){var i=!1;if(r=a,void 0!==(o="function"==typeof r?r.call(t,n,t,e):r)&&(e.exports=o),i=!0,e.exports=a(),i=!0,!i){var u=window.Cookies,l=window.Cookies=a();l.noConflict=function(){return window.Cookies=u,l}}}(function(){function e(){for(var e=0,t={};e<arguments.length;e++){var n=arguments[e];for(var r in n)t[r]=n[r]}return t}function t(n){function r(t,o,a){var i;if("undefined"!=typeof document){if(arguments.length>1){if(a=e({path:"/"},r.defaults,a),"number"==typeof a.expires){var u=new Date;u.setMilliseconds(u.getMilliseconds()+864e5*a.expires),a.expires=u}a.expires=a.expires?a.expires.toUTCString():"";try{i=JSON.stringify(o),/^[\{\[]/.test(i)&&(o=i)}catch(e){}o=n.write?n.write(o,t):encodeURIComponent(String(o)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g,decodeURIComponent),t=encodeURIComponent(String(t)),t=t.replace(/%(23|24|26|2B|5E|60|7C)/g,decodeURIComponent),t=t.replace(/[\(\)]/g,escape);var l="";for(var c in a)a[c]&&(l+="; "+c,!0!==a[c]&&(l+="="+a[c]));return document.cookie=t+"="+o+l}t||(i={});for(var s=document.cookie?document.cookie.split("; "):[],f=/(%[0-9A-Z]{2})+/g,d=0;d<s.length;d++){var p=s[d].split("="),h=p.slice(1).join("=");this.json||'"'!==h.charAt(0)||(h=h.slice(1,-1));try{var y=p[0].replace(f,decodeURIComponent);if(h=n.read?n.read(h,y):n(h,y)||h.replace(f,decodeURIComponent),this.json)try{h=JSON.parse(h)}catch(e){}if(t===y){i=h;break}t||(i[y]=h)}catch(e){}}return i}}return r.set=r,r.get=function(e){return r.call(r,e)},r.getJSON=function(){return r.apply({json:!0},[].slice.call(arguments))},r.defaults={},r.remove=function(t,n){r(t,"",e(n,{expires:-1}))},r.withConverter=t,r}return t(function(){})})},function(e,t,n){"use strict";function r(){}function o(){}var a=n(34);o.resetWarningCache=r,e.exports=function(){function e(e,t,n,r,o,i){if(i!==a){var u=new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");throw u.name="Invariant Violation",u}}function t(){return e}e.isRequired=e;var n={array:e,bool:e,func:e,number:e,object:e,string:e,symbol:e,any:e,arrayOf:t,element:e,elementType:e,instanceOf:t,node:e,objectOf:t,oneOf:t,oneOfType:t,shape:t,exact:t,checkPropTypes:o,resetWarningCache:r};return n.PropTypes=n,n}},function(e,t,n){"use strict";e.exports="SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"},,function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}Object.defineProperty(t,"__esModule",{value:!0});var o=n(1),a=r(o),i=n(3),u=r(i),l=n(7),c=r(l),s=n(2);n(41);var f={text:u.default.string.isRequired,img:u.default.string.isRequired},d=function(e){var t=e.text,n=e.img,r=(0,c.default)({bar:!0});return a.default.createElement("div",{className:r},a.default.createElement("div",{className:"bar-body"},a.default.createElement("img",{src:(0,s.getLink)(n),className:"front-img"}),a.default.createElement("span",null,t),a.default.createElement("img",{src:(0,s.getLink)(n),className:"back-img"})))};d.propTypes=f,t.default=d},,,,,function(e,t){},,,,,,,,,,,,,,,,function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default={"en-us":{barText:"Blog",postsTitle:"All posts",list:[{title:"Java new feature",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java new feature",link:"/en-us/blog/java/feature.html"},{title:"Java Class loading mechanism",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java Class loading mechanism",link:"/en-us/blog/java/load-class.html"},{title:"ORM merit and demerit",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"ORM,Orm merit and demerit",link:"/en-us/blog/java/orm.html"},{title:"Python new feature",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python new feature",link:"/en-us/blog/python/feature.html"},{title:"Python character operation",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python character operation",link:"/en-us/blog/python/str_joint.html"},{title:"Python syntax rule",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python syntax rule",link:"/en-us/blog/python/syntax_rule.html"},{title:"Data Split",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"Data Split",link:"/en-us/blog/sql/data_split.html"},{title:"Frame split",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"Frame split",link:"/en-us/blog/framework/split.html"},{title:"Distributed, High concurrency, Multithreading",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"Distributed, high concurrency, multithreading",link:"/en-us/blog/framework/fgb.html"},{title:"How to understand agile development",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"How to understand agile development",link:"/en-us/blog/framework/aglity.html"},{title:"Move towards the skills required of an architect",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"Move towards the skills required of an architect",link:"/en-us/blog/framework/fwork.html"}]},"zh-cn":{barText:"博客",postsTitle:"所有文章",list:[{title:"Java 新特性",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java 新特性",link:"/zh-cn/blog/java/feature.html"},{title:"Java 类加载机制",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Java 类加载机制",link:"/zh-cn/blog/java/load-class.html"},{title:"Orm的优缺点",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Java,Orm的优缺点",link:"/zh-cn/blog/java/orm.html"},{title:"Python 新特性",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python 新特性",link:"/zh-cn/blog/python/feature.html"},{title:"Python 字符操作",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python 字符操作",link:"/zh-cn/blog/python/str_joint.html"},{title:"Python 语法技巧",author:"BurningMyself",dateStr:"May 12nd，2018",desc:"Python,Python 语法技巧",link:"/zh-cn/blog/python/syntax_rule.html"},{title:"数据库拆分",author:"BurningMyself",dateStr:"May 12nd，2019",desc:"Database Split",link:"/zh-cn/blog/sql/data_split.html"}]}}},,,,,function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u,l=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),c=n(1),s=r(c),f=n(3),d=r(f),p=n(5),h=n(7),y=r(h),g=n(2);n(83);var m={pageSize:d.default.number},v={pageSize:5},b=(0,p.autobind)(u=function(e){function t(e){o(this,t);var n=a(this,(t.__proto__||Object.getPrototypeOf(t)).call(this,e));return n.container=null,n.state={page:0,pageWidth:0},n}return i(t,e),l(t,[{key:"componentDidMount",value:function(){var e=this,t=this.container.getBoundingClientRect().width;this.setState({pageWidth:t}),this.throttleAdjust=(0,g.throttle)(function(){e.setState({pageWidth:e.container.getBoundingClientRect().width})},200),window.addEventListener("resize",this.throttleAdjust)}},{key:"componentWillUnmount",value:function(){window.removeEventListener("resize",this.throttleAdjust)}},{key:"changePage",value:function(e){this.setState({page:e})}},{key:"renderSliderList",value:function(){for(var e=this.props,t=e.children,n=e.pageSize,r=this.state,o=r.page,a=r.pageWidth,i=[],u=s.default.Children.count(t),l=Math.ceil(u/n),c=0;c<l;c++)i.push(Array.from(t).slice(c*n,(c+1)*n));return s.default.createElement("div",{className:"slider-list",style:{transform:"translateX(-"+o*a+"px)",transition:"transform 500ms ease",width:l*a}},i.map(function(e,t){return s.default.createElement("div",{className:"slider-page",style:{width:a},key:t},e.map(function(e,t){return s.default.createElement("div",{className:"slider-item",key:t},e)}))}))}},{key:"renderControl",value:function(){var e=this.props,t=e.children,n=e.pageSize,r=this.state.page,o=s.default.Children.count(t),a=Math.ceil(o/n);return s.default.createElement("div",{className:"slider-control"},s.default.createElement("img",{className:(0,y.default)({"slider-control-prev":!0,"slider-control-prev-hidden":0===r}),src:(0,g.getLink)("/img/system/prev.png"),onClick:this.changePage.bind(this,r-1)}),s.default.createElement("img",{className:(0,y.default)({"slider-control-next":!0,"slider-control-next-hidden":r===a-1}),src:(0,g.getLink)("/img/system/next.png"),onClick:this.changePage.bind(this,r+1)}))}},{key:"render",value:function(){var e=this;return s.default.createElement("div",{className:"page-slider",ref:function(t){e.container=t}},this.renderSliderList(),this.renderControl())}}]),t}(s.default.Component))||u;b.propTypes=m,b.defaultProps=v,t.default=b},,,function(e,t,n){"use strict";function r(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function o(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var i,u=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),l=n(1),c=function(e){return e&&e.__esModule?e:{default:e}}(l),s=n(5),f=n(2);n(86);var d=(0,s.autobind)(i=function(e){function t(e){r(this,t);var n=o(this,(t.__proto__||Object.getPrototypeOf(t)).call(this,e));return n.state={isHovered:!1},n}return a(t,e),u(t,[{key:"onMouseOver",value:function(){this.setState({isHovered:!0})}},{key:"onMouseOut",value:function(){this.setState({isHovered:!1})}},{key:"render",value:function(){var e=this.props.dataSource,t=e.link,n=e.target,r=e.title,o=e.author,a=e.companyIcon,i=e.companyIconHover,u=e.dateStr,l=e.desc,s=this.state.isHovered;return c.default.createElement("a",{href:(0,f.getLink)(t),target:n||"_self",className:"blog-item",onMouseOver:this.onMouseOver,onMouseOut:this.onMouseOut},c.default.createElement("div",{className:"title"},c.default.createElement("img",{src:s?(0,f.getLink)("/img/system/docs_hover.png"):(0,f.getLink)("/img/system/docs_normal.png")}),c.default.createElement("span",null,r)),c.default.createElement("div",{className:"brief-info"},c.default.createElement("span",{className:"author"},o),a?c.default.createElement("img",{src:s?(0,f.getLink)(i):(0,f.getLink)(a)}):null,c.default.createElement("span",{className:"date"},u)),c.default.createElement("p",null,l))}}]),t}(c.default.Component))||i;t.default=d},,,,,,,function(e,t){},,,,,,function(e,t,n){"use strict";function r(e){return e&&e.__esModule?e:{default:e}}function o(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}Object.defineProperty(t,"__esModule",{value:!0});var u=function(){function e(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}return function(t,n,r){return n&&e(t.prototype,n),r&&e(t,r),t}}(),l=n(1),c=r(l),s=n(4),f=r(s),d=n(11),p=r(d),h=n(10),y=r(h),g=n(36),m=r(g),v=n(62),b=r(v),w=n(65),O=r(w),k=n(9),_=r(k),E=n(57),j=r(E),S=n(2);n(72);var P=function(e){function t(){return o(this,t),a(this,(t.__proto__||Object.getPrototypeOf(t)).apply(this,arguments))}return i(t,e),u(t,[{key:"render",value:function(){var e=this.getLanguage(),t=j.default[e],n=t.list;return c.default.createElement("div",{className:"blog-list-page"},c.default.createElement(y.default,{type:"normal",currentKey:"blog",logo:"/img/dubbo_colorful.png",language:e,onLanguageChange:this.onLanguageChange}),c.default.createElement(m.default,{img:"/img/system/blog.png",text:t.barText}),c.default.createElement("section",{className:"blog-container"},c.default.createElement("div",{className:"col col-18 left-part"},c.default.createElement(b.default,{pageSize:5},n.map(function(e,t){return c.default.createElement(O.default,{key:t,dataSource:e})}))),c.default.createElement("div",{className:"col col-6 right-part"},c.default.createElement("h4",null,t.postsTitle),c.default.createElement("ul",null,n.map(function(e,t){return c.default.createElement("li",{key:t},c.default.createElement("a",{href:(0,S.getLink)(e.link),target:e.target||"_self"},c.default.createElement("span",null,e.dateStr,"  "),c.default.createElement("span",null,e.title)))})))),c.default.createElement(_.default,{logo:"/img/dubbo_gray.png",language:e}))}}]),t}(p.default);document.getElementById("root")&&f.default.render(c.default.createElement(P,null),document.getElementById("root")),t.default=P},,,,,function(e,t){},,,function(e,t){}]);
\ No newline at end of file
diff --git a/en-us/blog/framework/agility.html b/en-us/blog/framework/agility.html
new file mode 100644
index 0000000..3f05e20
--- /dev/null
+++ b/en-us/blog/framework/agility.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+	<meta name="keywords" content="agility" />
+	<meta name="description" content="agility" />
+	<!-- 网页标签标题 -->
+	<title>agility</title>
+	<link rel="shortcut icon" href="/img/docsite.ico"/>
+	<link rel="stylesheet" href="/build/blogDetail.css" />
+</head>
+<body>
+	<div id="root"><div class="blog-detail-page" data-reactroot=""><header class="header-container header-container-normal"><div class="header-body"><a href="/en-us/index.html"><img class="logo" src="/img/dubbo_colorful.png"/></a><div class="search search-normal"><span class="icon-search"></span></div><span class="language-switch language-switch-normal">中</span><div class="header-menu"><img class="header-menu-toggle" src="/img/system/menu_gray.png"/><ul><li class="menu-item menu-item-normal"><a href="/en-us/index.html" target="_self">HOME</a></li><li class="menu-item menu-item-normal"><a href="/en-us/docs/introduction.html" target="_self">DOCS</a></li><li class="menu-item menu-item-normal menu-item-normal-active"><a href="/en-us/blog/index.html" target="_self">BLOG</a></li><li class="menu-item menu-item-normal"><a href="/en-us/community/index.html" target="_self">COMMUNITY</a></li></ul></div></div></header><section class="blog-content markdown-body"><h1>如何理解敏捷开发</h1>
+<h2>为什么要敏捷开发</h2>
+<p>“没有人喜欢敏捷，但我们不得不敏捷。就像没有人喜欢工作，但你必须工作。”这是我经常用来调侃敏捷的一句话。试想一下，拿到一份完整详尽的需求文档，逐个功能Coding，测试部署上线。不需要再次确认需求，不会有人打断思路。没有需求更改，只要自己不犯错，不存在推倒重来这才是大部分开发人员最舒服的工作方式吧，简直太完美了。但它很像瀑布，一点都不敏捷。既然我们喜欢的工作方式是传统的、瀑布的，为什么要敏捷？这还不都是市场环境逼的。今天的市场向我们提出了三个问题：</p>
+<h2>01如何做出真正满足用户需求的产品？</h2>
+<p>我不确定这世上是否有人可以做到，他所做出的全部决定都是对的。但绝大多数人是无法一次性做出真正满足用户需求的产品的。我们无法预测未来，我们必须通过一次次的测试，去寻找用户需要的产品是什么？想要更快地获得好的产品，必须迅速将产品推向市场，快速试验，避免走弯路。</p>
+<h2>02如何满足不断变化的用户需求？</h2>
+<p>今天所有的事情的都在快速变化，用户的需求也在变化。毫不夸张地说，我们正在全力开发的一些功能，当它们上线的时候，我们的用户已经不再需要了。我们没有办法让一切不变，我们只能选择去拥抱变化。</p>
+<h2>03如何同时满足不同层次用户的需求？</h2>
+<p>过去我们的产品会遵循产品生命周期，早期追求新奇的尝鲜者，中期普通大众，后期落后者。今天，产品的生命周期变化非常地快，我们可能会同时面对尝鲜者、普通大众、落后者，不同的用户类型的需求是不一样的，你如何满足他们？我们必须快速响应，没法快速响应，就没法留住用户，没有用户就没有一切。迅速将产品推向市场，拥抱变化、快速响应。今天的市场向所有的从业者提出了一个要求：拥有应对快速变化的需求的软件开发能力。而敏捷就是赋予团队应对快速变化的需求的软件开发能力的方法，而这就是敏捷流行的原因。</p>
+<h2>什么是敏捷开发</h2>
+<p>敏捷绝非某一种特定的开发方法，它只是一种应对快速变化的需求的一种软件开发能力。敏捷本身只包含了《敏捷软件开发宣言》和《敏捷软件的十二条原则》两份文档。敏捷相信，只要符合这两份文档的开发方法，就能让开发团队拥有应对快速变化需求的能力，这样的开发方法都叫做敏捷开发方法。</p>
+<h2>最流行的敏捷开发方式是什么</h2>
+<p>敏捷开发的方法有很多：ASD、AUP、DSDM、XP、FDD、Kanban、RAD、Scrum。目前国内最流行的应属Scrum。Scrum本意是指橄榄球运动中的“带球过人”，它可以解决非常复杂的项目，并且能高效并创造性地交付高价值的产品。Scrum包含3个角色、3个工件、5个价值观、5个事件 <a href="https://www.scrum.org/">详情https://www.scrum.org</a>。相比其他敏捷方法，Scrum既不简单又不复杂。它有完善的指南，你可以按照指南，轻易在团队内推广尝试。但想要实践好Scrum，又需要很好的技巧。这种易上手难精通的方法，特别适合培训机构。所以近几年，关于Scrum的培训机构遍地都是。可以说，在Scrum流行这件事上，这些培训机构做了很大的贡献。</p>
+<h2>如何实施Scrum</h2>
+<p>在团队中实施敏捷开发是一个很有挑战性的工作，尤其是Scrum这种描述比较详细、有很多规则的方法。</p>
+<p>**如果你打算把所有人召集到一起，宣布我们要实施敏捷开发Scrum，然后就照着Scrum的描述开发方法直接实施，那么，你离失败不远了。**想要实施好Scrum，你必须一步步来，一点一点改变团队的习惯，当一项新制度已经变成本能之后，再推行下一项制度。</p>
+<h3>&gt;&gt;&gt;&gt;第一步，先把团队的开发任务可视化。</h3>
+<p>你可以用一块白板，让团队成员把所有的开发任务都用便签写好放上去，也可以找一个专业的看板工具。我推荐日事清，当所有任务都在看板上，尽收眼底，那种感觉还是很棒的。团队中每个人的工作都会被所有人看到，会形成一种无形的监督。</p>
+<h3>&gt;&gt;&gt;&gt;第二步，引入站会制度。</h3>
+<p>当团队所有人的任务都在看板后，这些任务的状态是需要有人更新的。无论是专人更新，还是每个人自己更新，都会出现忘记更新，更新不及时的情况。这时，就可以顺势引入站会制度了。每天上班的时候，或者每天下班的时候，所有人站到一起，花15分钟，说一下自己做了什么，准备做什么，所有人一起把看板更新了。</p>
+<h3>&gt;&gt;&gt;&gt;第三步，引入回顾会议</h3>
+<p>当站会制度成熟后，就可以挑一个版本发布的日子。等版本发布后，把团队成员叫到一起，开一个回顾会。让团队成员对这个版本开发的情况做个总结，同时可以让大家用便签把这个开发版本遇到的问题、不满写下来。针对这些问题不满，大家一起讨论一些改进方案。</p>
+<h3>&gt;&gt;&gt;&gt;第四步，引入计划会议</h3>
+<p>如果再开回顾会的时候，有人提出需求不清，拆解不够细致，工时估算不准之类的问题，那你真是太幸运了。碰到这种情况，你顺势提出这个制度：每个版本开发前，产品经理要和团队人员开个会，一起逐条对需求。产品经理要向团队解释每个需求，并且对团队提出的疑问进行解释和澄清。开发团队要将需求分解成任务，估算工时，最终形成一个开发清单。</p>
+<h3>&gt;&gt;&gt;&gt;第五步，引入评审会议</h3>
+<p>当计划会成功开过几次之后，就可以考虑引入评审会了。你可以在某个重大功能发布的时候，把所有项目相关的人员召集起来，向大家展示团队做了哪些了不起的功能，也可以和大家讨论讨论还可以做哪些优化。</p>
+<h3>&gt;&gt;&gt;&gt;第六步，宣布引入Scrum</h3>
+<p>当整个流程都跑顺以后，就可以在某次全体会议上，提出我们要实施Scrum了。你需要任命PO、SM，对团队培训Scrum知识，讲解Scrum的价值观。</p>
+<h2>实施敏捷开发会面临怎样的挑战</h2>
+<p>1.团队成员对变化的恐惧</p>
+<p>实施Scrum最大的挑战来自内部，来自团队对变化的恐惧。每个团队在运营一段时间后都会形成固有的默契和习惯，引入Scrum必然会打破这种习惯。这会让团队很不舒服，团队也会抵制，甚至是反抗。而且实施敏捷的过程，一定不是一帆风顺的，尤其是实施敏捷的早期阶段，不仅不会对团队产生太大的价值，反而会引起混乱。所以，在实施敏捷的过程中，千万要小心，每次只改变一点点，敏捷地完成敏捷。</p>
+<p>2.组织人员的专业化水</p>
+<p>平敏捷并不会直接提高团队的专业化水平，反而对团队专业化水平有一定的要求。必要的专业分工、合适的专业能力是必须的。敏捷会让开发整个流程持续运转，当某一个环节专业化能力出现问题的时候，会极大地导致整个流程运转停滞。平时团队中的问题会在敏捷中快速暴露。一旦出现专业水平问题，要及时解决，补充人员，或者帮助其提高能力。即使问题并不严重，也要在最短的时间解决，否则会影响团队对敏捷的信心。</p>
+<p>3.产品经理这个组织Bug</p>
+<p>国内在实施Scrum的时候经常会碰到的问题就是团队中会有产品经理这个角色。</p>
+<p><strong>一般的处理方法是产品经理当PO</strong>，但PO是需要领导开发团队的。国内的产品经理往往不是技术出身，领导开发团队会出很多问题，所以产品经理并不适合当PO。</p>
+<p><strong>另一种做法是产品经理做利益相关者</strong>，这种做法更不靠谱，利益相关者离团队太远，会出现无法及时响应的问题，时间长了也会导致产品和开发之间关系冷漠，出现隔阂。我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>
+<p>我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>
+<p>另外腾讯企业微信里<a href="https://www.tapd.cn"><strong>TAPD</strong></a>也是不错的</p>
+</section><footer class="footer-container"><div class="footer-body"><img src="/img/dubbo_gray.png"/><div class="cols-container"><div class="col col-12"><h3>Disclaimer</h3><p>the disclaimer content</p></div><div class="col col-6"><dl><dt>Documentation</dt><dd><a href="/en-us/docs/introduction.html" target="_self">Overview</a></dd><dd><a href="/en-us/docs/introduction.html" target="_self">Quick start</a></dd><dd><a href="/en-us/docs/dir/introduction.html" target="_self">Developer guide</a></dd></dl></div><div class="col col-6"><dl><dt>Resources</dt><dd><a href="/en-us/blog/index.html" target="_self">Blog</a></dd><dd><a href="/en-us/community/index.html" target="_self">Community</a></dd></dl></div></div><div class="copyright"><span>Copyright © 2018 BurningMyself</span></div></div></footer></div></div>
+	<script src="https://f.alicdn.com/react/15.4.1/react-with-addons.min.js"></script>
+	<script src="https://f.alicdn.com/react/15.4.1/react-dom.min.js"></script>
+	<script>
+		window.rootPath = '';
+  </script>
+	<script src="/build/blogDetail.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/en-us/blog/framework/agility.json b/en-us/blog/framework/agility.json
new file mode 100644
index 0000000..e3a7ea1
--- /dev/null
+++ b/en-us/blog/framework/agility.json
@@ -0,0 +1,6 @@
+{
+  "filename": "agility.md",
+  "__html": "<h1>如何理解敏捷开发</h1>\n<h2>为什么要敏捷开发</h2>\n<p>“没有人喜欢敏捷，但我们不得不敏捷。就像没有人喜欢工作，但你必须工作。”这是我经常用来调侃敏捷的一句话。试想一下，拿到一份完整详尽的需求文档，逐个功能Coding，测试部署上线。不需要再次确认需求，不会有人打断思路。没有需求更改，只要自己不犯错，不存在推倒重来这才是大部分开发人员最舒服的工作方式吧，简直太完美了。但它很像瀑布，一点都不敏捷。既然我们喜欢的工作方式是传统的、瀑布的，为什么要敏捷？这还不都是市场环境逼的。今天的市场向我们提出了三个问题：</p>\n<h2>01如何做出真正满足用户需求的产品？</h2>\n<p>我不确定这世上是否有人可以做到，他所做出的全部决定都是对的。但绝大多数人是无法一次性做出真正满足用户需求的产品的。我们无法预测未来，我们必须通过一次次的测试，去寻找用户需要的产品是什么？想要更快地获得好的产品，必须迅速将产品推向市场，快速试验，避免走弯路。</p>\n<h2>02如何满足不断变化的用户需求？</h2>\n<p>今天所有的事情的都在快速变化，用户的需求也在变化。毫不夸张地说，我们正在全力开发的一些功能，当它们上线的时候，我们的用户已经不再需要了。我们没有办法让一切不变，我们只能选择去拥抱变化。</p>\n<h2>03如何同时满足不同层次用户的需求？</h2>\n<p>过去我们的产品会遵循产品生命周期，早期追求新奇的尝鲜者，中期普通大众，后期落后者。今天，产品的生命周期变化非常地快，我们可能会同时面对尝鲜者、普通大众、落后者，不同的用户类型的需求是不一样的，你如何满足他们？我们必须快速响应，没法快速响应，就没法留住用户，没有用户就没有一切。迅速将产品推向市场，拥抱变化、快速响应。今天的市场向所有的从业者提出了一个要求：拥有应对快速变化的需求的软件开发能力。而敏捷就是赋予团队应对快速变化的需求的软件开发能力的方法，而这就是敏捷流行的原因。</p>\n<h2>什么是敏捷开发</h2>\n<p>敏捷绝非某一种特定的开发方法，它只是一种应对快速变化的需求的一种软件开发能力。敏捷本身只包含了《敏捷软件开发宣言》和《敏捷软件的十二条原则》两份文档。敏捷相信，只要符合这两份文档的开发方法，就能让开发团队拥有应对快速变化需求的能力，这样的开发方法都叫做敏捷开发方法。</p>\n<h2>最流行的敏捷开发方式是什么</h2>\n<p>敏捷开发的方法有很多：ASD、AUP、DSDM、XP、FDD、Kanban、RAD、Scrum。目前国内最流行的应属Scrum。Scrum本意是指橄榄球运动中的“带球过人”，它可以解决非常复杂的项目，并且能高效并创造性地交付高价值的产品。Scrum包含3个角色、3个工件、5个价值观、5个事件 <a href=\"https://www.scrum.org/\">详情https://www.scrum.org</a>。相比其他敏捷方法，Scrum既不简单又不复杂。它有完善的指南，你可以按照指南，轻易在团队内推广尝试。但想要实践好Scrum，又需要很好的技巧。这种易上手难精通的方法，特别适合培训机构。所以近几年，关于Scrum的培训机构遍地都是。可以说，在Scrum流行这件事上，这些培训机构做了很大的贡献。</p>\n<h2>如何实施Scrum</h2>\n<p>在团队中实施敏捷开发是一个很有挑战性的工作，尤其是Scrum这种描述比较详细、有很多规则的方法。</p>\n<p>**如果你打算把所有人召集到一起，宣布我们要实施敏捷开发Scrum，然后就照着Scrum的描述开发方法直接实施，那么，你离失败不远了。**想要实施好Scrum，你必须一步步来，一点一点改变团队的习惯，当一项新制度已经变成本能之后，再推行下一项制度。</p>\n<h3>&gt;&gt;&gt;&gt;第一步，先把团队的开发任务可视化。</h3>\n<p>你可以用一块白板，让团队成员把所有的开发任务都用便签写好放上去，也可以找一个专业的看板工具。我推荐日事清，当所有任务都在看板上，尽收眼底，那种感觉还是很棒的。团队中每个人的工作都会被所有人看到，会形成一种无形的监督。</p>\n<h3>&gt;&gt;&gt;&gt;第二步，引入站会制度。</h3>\n<p>当团队所有人的任务都在看板后，这些任务的状态是需要有人更新的。无论是专人更新，还是每个人自己更新，都会出现忘记更新，更新不及时的情况。这时，就可以顺势引入站会制度了。每天上班的时候，或者每天下班的时候，所有人站到一起，花15分钟，说一下自己做了什么，准备做什么，所有人一起把看板更新了。</p>\n<h3>&gt;&gt;&gt;&gt;第三步，引入回顾会议</h3>\n<p>当站会制度成熟后，就可以挑一个版本发布的日子。等版本发布后，把团队成员叫到一起，开一个回顾会。让团队成员对这个版本开发的情况做个总结，同时可以让大家用便签把这个开发版本遇到的问题、不满写下来。针对这些问题不满，大家一起讨论一些改进方案。</p>\n<h3>&gt;&gt;&gt;&gt;第四步，引入计划会议</h3>\n<p>如果再开回顾会的时候，有人提出需求不清，拆解不够细致，工时估算不准之类的问题，那你真是太幸运了。碰到这种情况，你顺势提出这个制度：每个版本开发前，产品经理要和团队人员开个会，一起逐条对需求。产品经理要向团队解释每个需求，并且对团队提出的疑问进行解释和澄清。开发团队要将需求分解成任务，估算工时，最终形成一个开发清单。</p>\n<h3>&gt;&gt;&gt;&gt;第五步，引入评审会议</h3>\n<p>当计划会成功开过几次之后，就可以考虑引入评审会了。你可以在某个重大功能发布的时候，把所有项目相关的人员召集起来，向大家展示团队做了哪些了不起的功能，也可以和大家讨论讨论还可以做哪些优化。</p>\n<h3>&gt;&gt;&gt;&gt;第六步，宣布引入Scrum</h3>\n<p>当整个流程都跑顺以后，就可以在某次全体会议上，提出我们要实施Scrum了。你需要任命PO、SM，对团队培训Scrum知识，讲解Scrum的价值观。</p>\n<h2>实施敏捷开发会面临怎样的挑战</h2>\n<p>1.团队成员对变化的恐惧</p>\n<p>实施Scrum最大的挑战来自内部，来自团队对变化的恐惧。每个团队在运营一段时间后都会形成固有的默契和习惯，引入Scrum必然会打破这种习惯。这会让团队很不舒服，团队也会抵制，甚至是反抗。而且实施敏捷的过程，一定不是一帆风顺的，尤其是实施敏捷的早期阶段，不仅不会对团队产生太大的价值，反而会引起混乱。所以，在实施敏捷的过程中，千万要小心，每次只改变一点点，敏捷地完成敏捷。</p>\n<p>2.组织人员的专业化水</p>\n<p>平敏捷并不会直接提高团队的专业化水平，反而对团队专业化水平有一定的要求。必要的专业分工、合适的专业能力是必须的。敏捷会让开发整个流程持续运转，当某一个环节专业化能力出现问题的时候，会极大地导致整个流程运转停滞。平时团队中的问题会在敏捷中快速暴露。一旦出现专业水平问题，要及时解决，补充人员，或者帮助其提高能力。即使问题并不严重，也要在最短的时间解决，否则会影响团队对敏捷的信心。</p>\n<p>3.产品经理这个组织Bug</p>\n<p>国内在实施Scrum的时候经常会碰到的问题就是团队中会有产品经理这个角色。</p>\n<p><strong>一般的处理方法是产品经理当PO</strong>，但PO是需要领导开发团队的。国内的产品经理往往不是技术出身，领导开发团队会出很多问题，所以产品经理并不适合当PO。</p>\n<p><strong>另一种做法是产品经理做利益相关者</strong>，这种做法更不靠谱，利益相关者离团队太远，会出现无法及时响应的问题，时间长了也会导致产品和开发之间关系冷漠，出现隔阂。我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>\n<p>我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>\n<p>另外腾讯企业微信里<a href=\"https://www.tapd.cn\"><strong>TAPD</strong></a>也是不错的</p>\n",
+  "link": "\\en-us\\blog\\framework\\agility.html",
+  "meta": {}
+}
\ No newline at end of file
diff --git a/en-us/blog/framework/fwork.html b/en-us/blog/framework/fwork.html
new file mode 100644
index 0000000..bd267f0
--- /dev/null
+++ b/en-us/blog/framework/fwork.html
@@ -0,0 +1,135 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+	<meta name="keywords" content="fwork" />
+	<meta name="description" content="fwork" />
+	<!-- 网页标签标题 -->
+	<title>fwork</title>
+	<link rel="shortcut icon" href="/img/docsite.ico"/>
+	<link rel="stylesheet" href="/build/blogDetail.css" />
+</head>
+<body>
+	<div id="root"><div class="blog-detail-page" data-reactroot=""><header class="header-container header-container-normal"><div class="header-body"><a href="/en-us/index.html"><img class="logo" src="/img/dubbo_colorful.png"/></a><div class="search search-normal"><span class="icon-search"></span></div><span class="language-switch language-switch-normal">中</span><div class="header-menu"><img class="header-menu-toggle" src="/img/system/menu_gray.png"/><ul><li class="menu-item menu-item-normal"><a href="/en-us/index.html" target="_self">HOME</a></li><li class="menu-item menu-item-normal"><a href="/en-us/docs/introduction.html" target="_self">DOCS</a></li><li class="menu-item menu-item-normal menu-item-normal-active"><a href="/en-us/blog/index.html" target="_self">BLOG</a></li><li class="menu-item menu-item-normal"><a href="/en-us/community/index.html" target="_self">COMMUNITY</a></li></ul></div></div></header><section class="blog-content markdown-body"><h1>走向架构师必备的技能</h1>
+<p>中国有很多年轻人，他们18,9岁或21,2岁，通过自学也写了不少代码，他们有的代码写的很漂亮，一些技术细节相当出众，也很有钻研精神，但是他们被一些错误的认识和观点左右，缺乏对系统，对程序的整体理解能力，这些人，一个网上的朋友说得很好，他们实际fans，压根没有资格称为程序员，但是据我所知，不少小网络公司的Cfans,拿着吓人的工资，做着吓人的项目，项目的结局通常也很吓人。</p>
+<h2>程序员基本素质：</h2>
+<p>作一个真正合格的程序员，或者说就是可以真正合格完成一些代码工作的程序员，应该具有的素质。</p>
+<ol>
+<li>团队精神和协作能力</li>
+</ol>
+<p>把它作为基本素质，并不是不重要，恰恰相反，这是程序员应该具备的最基本的，也是最重要的安身立命之本。把高水平程序员说成独行侠的都是在呓语，任何个人的力量都是有限的，即便如linus这样的天才，也需要通过组成强大的团队来创造奇迹，那些遍布全球的为linux写核心的高手们，没有协作精神是不可想象的。独行侠可以作一些赚钱的小软件发点小财，但是一旦进入一些大系统的研发团队，进入商业化和产品化的开发任务，缺乏这种素质的人就完全不合格了。</p>
+<ol start="2">
+<li>文档习惯</li>
+</ol>
+<p>说高水平程序员从来不写文档的肯定是乳臭未干的毛孩子，良好的文档是正规研发流程中非常重要的环节，作为代码程序员，30％的工作时间写技术文档是很正常的，而作为高级程序员和系统分析员，这个比例还要高很多。缺乏文档，一个软件系统就缺乏生命力，在未来的查错，升级以及模块的复用时就都会遇到极大的麻烦。</p>
+<ol start="3">
+<li>规范化，标准化的代码编写习惯</li>
+</ol>
+<p>作为一些外国知名软件公司的规矩，代码的变量命名，代码内注释格式，甚至嵌套中行缩进的长度和函数间的空行数字都有明确规定，良好的编写习惯，不但有助于代码的移植和纠错，也有助于不同技术人员之间的协作。
+fans叫嚣高水平程序员写的代码旁人从来看不懂，这种叫嚣只能证明他们自己压根不配自称程序员。代码具有良好的可读性，是程序员基本的素质需求。
+再看看整个linux的搭建，没有规范化和标准化的代码习惯，全球的研发协作是绝对不可想象的。</p>
+<ol start="4">
+<li>需求理解能力</li>
+</ol>
+<p>程序员需要理解一个模块的需求，很多小朋友写程序往往只关注一个功能需求，他们把性能指标全部归结到硬件，操作系统和开发环境上，而忽视了本身代码的性能考虑，有人曾经放言说写一个广 告交换程序很简单，这种人从来不知道在百万甚至千万数量级的访问情况下的性能指标是如何实现的，对于这样的程序员，你给他深蓝那套系统，他也做不出太极链的并访能力。性能需求指标中，稳定性，并访支撑能力以及安全性都很重要，作为程序员需要评估该模块在系统运营中所处的环境，将要受到的负荷压力以及各种潜在的危险和恶意攻击的可能性。就这一点，一个成熟的程序员至少需要2到3年的项目研发和跟踪经验才有可能有心得。</p>
+<ol start="5">
+<li>复用性，模块化思维能力</li>
+</ol>
+<p>经常可以听到一些程序员有这样的抱怨，写了几年程序，变成了熟练工，每天都是重复写一些没有任何新意的代码，这其实是中国软件人才最大浪费的地方，一些重复性工作变成了熟练程序员的主要工作，而这些，其实是完全可以避免的。</p>
+<p>复用性设计，模块化思维就是要程序员在完成任何一个功能模块或函数的时候，要多想一些，不要局限在完成当前任务的简单思路上，想想看该模块是否可以脱离这个系统存在，是否可以通过简单的修改参数的方式在其他系统和应用环境下直接引用，这样就能极大避免重复性的开发工作，如果一个软件研发单位和工作组能够在每一次研发过程中都考虑到这些问题，那么程序员就不会在重复性的工作中耽误太多时间，就会有更多时间和精力投入到创新的代码工作中去。</p>
+<p>一些好的程序模块代码，即便是70年代写成的，拿到现在放到一些系统里面作为功能模块都能适合的很好，而现在我看到的是，很多小公司软件一升级或改进就动辄全部代码重写，大部分重复性工作无谓的浪费了时间和精力。</p>
+<ol start="6">
+<li>测试习惯</li>
+</ol>
+<p>作为一些商业化正规化的开发而言，专职的测试工程师是不可少的，但是并不是说有了专职的测试工程师程序员就可以不进行自测；软件研发作为一项工程而言，一个很重要的特点就是问题发现的越早，解决的代价就越低，程序员在每段代码，每个子模块完成后进行认真的测试，就可以尽量将一些潜在的问题最早的发现和解决，这样对整体系统建设的效率和可靠性就有了最大的保证。</p>
+<p>测试工作实际上需要考虑两方面，一方面是正常调用的测试，也就是看程序是否能在正常调用下完成基本功能，这是最基本的测试职责，可惜在很多公司这成了唯一的测试任务，实际上还差的远那；第二方面就是异常调用的测试，比如高压力负荷下的稳定性测试，用户潜在的异常输入情况下的测试，整体系统局部故障情况下该模块受影响状况的测试，频发的异常请求阻塞资源时的模块稳定测试等等。当然并不是程序员要对自己的每段代码都需要进行这种完整测试，但是程序员必须清醒认识自己的代码任务在整体项目中的地位和各种性能需求，有针对性的进行相关测试并尽早发现和解决问题，当然这需要上面提到需求理解能力。</p>
+<ol start="7">
+<li>学习和总结的能力</li>
+</ol>
+<p>程序员是人才很容易被淘汰，很容易落伍的职业，因为一种技术可能仅仅在三两年内具有领先性，程序员如果想安身立命，就必须不断跟进新的技术，学习新的技能。</p>
+<p>善于学习，对于任何职业而言，都是前进所必需的动力，对于程序员，这种要求就更加高了。但是学习也要找对目标，一些小coding有些codingTO就是这样的coding上只是一些Cfans们，他们也津津乐道于他们的学习能力，一会学会了asp，一会儿学会了php，一会儿学会了jsp，他们把这个作为炫耀的资本，盲目的追逐一些肤浅的，表面的东西和名词，做网络程序不懂通讯传输协议，做应用程序不懂中断向量处理，这样的技术人员，不管掌握了多少所谓的新语言，永远不会有质的提高。</p>
+<p>善于总结，也是学习能力的一种体现，每次完 成一个研发任务，完成一段代码，都应当有目的的跟踪该程序的应用状况和用户反馈，随时总结，找到自己的不足，这样逐步提高，一个程序员才可能成长起来。</p>
+<p>一个不具备成长性的程序员，即便眼前看是个高手，建议也不要选用，因为他落伍的时候马上就到了。具备以上全部素质的人，应当说是够格的程序员了，请注意以上的各种素质都不是由IQ决定的，也不是大学某些课本里可以学习到的，需要的仅仅是程序员对自己工作的认识，是一种意识上的问题。</p>
+<h2>高级程序员</h2>
+<p>那么作为高级程序员，以至于系统分析员，也就是对于一个程序项目的设计者而言，除了应该具备上述全部素质之外，还需要具备以下素质：</p>
+<ol>
+<li>需求分析能力</li>
+</ol>
+<p>对于程序员而言，理解需求就可以完成合格的代码，但是对于研发项目的组织和管理者，他们不但要理解客户需求，更多时候还要自行制定一些需求，为什么这么说呢？</p>
+<p>一般而言，进行研发任务，也许是客户提出需求，也许是市场和营销部门提出的需求，这时候对于研发部门，他们看到的不是一个完整的需求，通常而言，该需求仅仅是一些功能上的要求，或者更正规些，可能获得一个完整的用户视图；但是这都不够，因为客户由于非技术因素多一些，他们可能很难提出完整和清晰，或者说专业性的性能需求，但是对于项目组织者和规划者，他必须能够清醒认识到这些需求的存在并在完成 需求分析报告的时候适当的提出，同时要完整和清晰的体现在设计说明书里面，以便于程序员编码时不会失去这些准则。</p>
+<p>程序设计者必须正确理解用户需求所处的环境，并针对性做出需求的分析，举例而言，同样一个软件通过ASP租用方式发布和通过License方式发布，性能需求可能就是有区别的，前者强调的是更好的支撑能力和稳定性，而后者则可能更强调在各种平台下的普适性和安装使用的简捷性。</p>
+<ol start="2">
+<li>项目设计方法和流程处理能力</li>
+</ol>
+<p>程序设计者必须能够掌握不少于两到三种的项目设计方法（比如自顶至下的设计方法，比如快速原型法等等），并能够根据项目需求和资源搭配来选择合适的设计方法进行项 目的整体设计。设计方法上选择不当，就会耽误研发周期，浪费研发资源，甚至影响研发效果。</p>
+<p>一个程序设计者还需要把很多功夫用在流程图的设计和处理上，他需要做数据流图以确立数据词典；他需要加工逻辑流图以形成整体的系统处理流程。一个流程有问题的系统，就算代码多漂亮，每个模块多精致，也不会成为一个好的系统。当然，做好流程分析并选择好项目设计方法，都需要在需求分析能力上具有足够的把握。</p>
+<ol start="3">
+<li>复用设计和模块化分解能力</li>
+</ol>
+<p>这个似乎又是老调重谈，前面基本素质上不是已经说明了这个问题吗？作为一个从事模块任务的程序员，他需要对他所面对的特定功能模块的 复用性进行考虑，而作为一个系统分析人员，他要面对的问题复杂的多，需要对整体系统按照一种模块化的分析能力分解为很多可复用的功能模块和函数，并针对每一模块形成一个独立的设计需求。举个例子，好比是汽车生产，最早每辆汽车都是独立安装的，每个部件都是量身定做的，但是后来不一样了，机器化大生产了，一个汽车厂开始通过流水线来生产汽车，独立部件开始具有一定的复用性，在后来标准化成为大趋势，不同型号，品牌甚至不同厂商的汽车部件也可以进行方便的换装和升级，这时候，汽车生产的效率达到最大化。软件工程也是同样的道理，一个成熟的软件行业，在一些相关项目和系统中，不同的部件是可以随意换装的，比如微软的许多桌面软件，在很多操作模块（如打开文件，保存文件等等）都是复用的同一套功能模块，而这些接口又通过一些类库提供给了桌面应用程序开发者方便挂接，这就是复用化的模块设计明显的一个佐证。</p>
+<p>将一个大型的，错综复杂的应用系统分解成一些相对独立的，具有高度复用性的，并能仅仅依靠几个参数完成数据联系的模块组合，是作为高级程序员和系统分析员一项最重要的工作，合适的项目设计方法，清晰的流程图，是实现这一目标的重要保证。</p>
+<ol start="4">
+<li>整体项目评估能力</li>
+</ol>
+<p>作为系统设计人员，必须能够从全局出发，对项目又整体的清醒认识，比如公司的资源配置是否合理和到位，比如工程进度安排是否能最大化体现效率又不至于无法按期完成。评估项 目整体和各个模块的工作量，评估项目所需的资源，评估项目可能遇到的困难，都需要大量的经验积累，换言之，这是一种不断总结的累计才能达到的境界。在西方一些软件系统设计的带头人都是很年长的，比如4，50岁，甚至更老，他们在编码方面已经远远不如年轻人那样活络，但是就项目评估而言，他们几十年的经验积累就是最重要和宝贵的财富。中国缺这么一代程序员，主要还不是缺那种年纪的程序员，而是那种年纪的程序员基本上都是研究单位作出来的，都不是从专业的产品化软件研发作出来的，他们没有能积累那种产品化研发的经验，这也是没有办法的事情。</p>
+<ol start="5">
+<li>团队组织管理能力</li>
+</ol>
+<p>完成一个项目工程，需要团队的齐心协力，作为项目设计者或研发的主管人，就应当有能力最大化发挥团队的整体力量，技术管理由于其专业性质，不大同于一般的人事管理，因为这里面设计了一些技术性的指标和因素。</p>
+<p>首先是工作的量化，没有量化就很难做到合适的绩效考核，而程序量化又不是简单的代码行数可以计算的，因此要求技术管理人员需要能真正评估一个模块的复杂性和工作量。</p>
+<p>其次是对团队协作模式的调整，一般而言，程序开发的协作通常分为小组进行，小组有主程序员方式的，也有民主方式的，根据程序员之间的能力水平差距，以及根据项目研发的需求，选择合适的组队方式，并能将责权和成员的工作任务紧密结合，这样才能最大发挥组队的效率。</p>
+<p>一个代码水平高的人，未必能成为一个合格的项目研发主管，这方面的能力欠缺往往是容易被忽视的。</p>
+<p>综上可以看到，作为一个主管研发的负责人，一个项目设计者，所需要具备的素质和能力并不是程序代码编写的能力，当然一般情况下，一个程序员通过不断的总结提高达到了这种素质的时候，他所具有的代码编写能力也已经相当不简单了，但是请注意这里面的因果关系，一个高水平的项目设计者通常已经是代码编写相当优秀的人了，但是并不是一个代码相当优秀的程序员就可以胜任项目设计的工作，这里面存在的也不是智商和课本的问题，还是在于一个程序员在积累经验，逐步提升的时候没有意识到应当思考哪方面的东西，没有有意识的就项目的组织和复用设计进行揣摩，没有经常性的文档习惯和总结习惯， 不改变这些，我们的合格的项目设计者还是非常欠缺。</p>
+<p>另外，为防止有无聊的人和我较真，补充一点，本文针对目标是作商业化的软件项目和工程，那些科研机构的编程高手，比如算法高手，比如图象处理高手，他们的工作是研究课题而非直接完成商业软件（当然最终间接成为商业产品，比如微软研究院在作的研究课题），因此他们强调的素质可能是另外的东西，这些人（专家），并不能说是程序员，不能用程序员的标准去衡量。</p>
+<p>最后补充一点东西，一个软件项目研发的设计流程是怎样的呢？以通常标准的设计方法为例，（不过笔者喜欢快速原型法）。</p>
+<ul>
+<li>
+<p>第一个步骤是市场调研，技术和市场要结合才能体现最大价值。</p>
+</li>
+<li>
+<p>第二个步骤是需求分析，这个阶段需要出三样东西，用户视图，数据词典和用户操作手册。用户视图是该软件用户（包括终端用户和管理用户）所能看到的页面样式，这里面包含了很多操作方面的流程和条件。数据词典是指明数据逻辑关系并加以整理的东东，完成了数据词典，数据库的设计就完成了一半多。用户操作手册是指明了操作流程的说明书。</p>
+</li>
+</ul>
+<p>注意，用户操作流程和用户视图是由需求决定的，因此应该在软件设计之前完成，完成这些，就为程序研发提供了约束和准绳，很遗憾太多公司都不是这样做的，因果颠倒，顺序不分，开发工作和实际需求往往因此 产生隔阂脱节的现象。</p>
+<p>需求分析，除了以上工作，笔者以为作为项目设计者应当完整的做出项目的性能需求说明书，因为往往性能需求只有懂技术的人才可能理解，这就需要技术专家和需求方（客户或公司市场部门）能够有真正的沟通和了解。</p>
+<ul>
+<li>
+<p>第三个步骤是概要设计，将系统功能模块初步划分，并给出合理的研发流程和资源要求。作为快速原型设计方法，完成概要设计就可以进入编码阶段了，通常采用这种方法是因为涉及的研发任务属于新领域，技术主管人员一上来无法给出明确的详细设计说明书，但是并不是说详细设计说明书不重要，事实上快速原型法在完成原型代码后，根据评测结果和经验教训的总结，还要重新进行详细设计的步骤。</p>
+</li>
+<li>
+<p>第四个步骤是详细设计，这是考验技术专家设计思维的重 要关卡，详细设计说明书应当把具体的模块以最‘干净’的方式(黑箱结构）提供给编码者，使得系统整体模块化达到最大；一份好的详细设计说明书，可以使编码的复杂性减低到最低，实际上，严格的讲详细设计说明书应当把每个函数的每个参数的定义都精精细细的提供出来，从需求分析到概要设计到完成详细设计说明书，一个软件项目就应当说完成了一半了。换言之，一个大型软件系统在完成了一半的时候，其实还没有开始一行代码工作。那些把作软件的程序员简单理解为写代码的，就从根子上犯了错误了。</p>
+</li>
+<li>
+<p>第五个步骤是编码，在规范化的研发流程中，编码工作在整个项目流程里最多不会超过1/2，通常在1/3的时间，所谓磨刀不误砍柴功，设计过程完成的好，编码效率就会极大提高，编码时不同模块之间的进度协调和协作是最需要小心的，也许一个小模块的问题就可能影响了整体进度，让很多程序员因此被迫停下工作等待，这种问题在很多研发过程中都出现过。编码时的相互沟通和应急的解决手段都是相当重要的，对于程序员而言，bug永远存在，你必须永远面对这个问题，大名鼎鼎的微软，可曾有连续三个月不发补丁的时候吗？从来没有！</p>
+</li>
+<li>
+<p>第六个步骤是测试</p>
+</li>
+</ul>
+<p>测试有很多种：按照测试执行方，可以分为内部测试和外部测试；按照测试范围，可以分为模块测试和整体联调；按照测试条 件，可以分为正常操作情况测试和异常情况测试；按照测试的输入范围，可以分为全覆盖测试和抽样测试。以上都很好理解，不再解释。</p>
+<p>总之，测试同样是项目研发中一个相当重要的步骤，对于一个大型软件，3个月到1年的外部测试都是正常的，因为永远都会又不可预料的问题存在。</p>
+<p>完成测试后，完成验收并完成最后的一些帮助文档，整体项目才算告一段落，当然日后少不了升级，修补等等工作，只要不是想通过一锤子买卖骗钱，就要不停的跟踪软件的运营状况并持续修补升级，知道这个软件被彻底淘汰为止。</p>
+<p>写这些步骤算不上卖弄什么，因为实话讲我手边是一本《软件工程》，在大学里这是计算机专业的必修课程，但是我知道很多程序员似乎从来都只是热衷于什么《30天精通VC》之类的，他们有些和我一样游击队出身，没有正规学过这个专业，还有一些则早就在混够学分后就把这些真正有用的东西还给了老师。</p>
+<p>fans乱嚷嚷，混淆视听，实际上真正的技术专家很少在网上乱发帖子的，如笔者这样不知天高地厚的，其实实在是算不上什么高手，只不过看不惯这种对技术，对程序员的误解和胡说，只好挺身而出，做拨乱反正之言，也希望那些还fans们能认真想想，走到正途上，毕竟那些聪明的头脑还远远没有发挥应有的价值。沉迷于一些错误人士的coding</p>
+<p>从程序员升级到工程师大多数象我这样对软件有浓厚兴趣的人，毕业后义无反顾地走进了企业，开始了程序员的生涯。那时，我们迷恋“大全”、“秘籍”一类的书籍，心中只有代码。当我看到一行行枯燥的代码变成了能够打电话的设备，变成了屏幕上漂亮的表格，变成了动听的音乐，成就感油然而生。我觉得自己也是一个出色的程序员了。在用户的机房中苦熬三昼夜解决软件的bug，也成了一种可以夸耀的资历。五年前的某一天，我把曾经让我兴奋自豪的大量代码和少得可怜的文档移交之后，来到了华为。这里有更多的年轻人，我如鱼得水，可以充分发挥自己的想象力。依然是代码，依然是匆匆地在纸上记下稍纵即逝的灵感（我们把它称作文档），依然是无休止地和bug作斗争。当有一天，一个新来 的同事拿着署着我的大名的文档，小心翼翼地来问我时，我发现自己好象有点不认识它了。我心里有点沮丧，再看看代码，发现文档上记录的一些灵感已面目全非。我当时不知道那位新来的同事感受如何，但我从那时起，好象意识到什么。现在来看，那时的很多事情都是事倍功半。</p>
+<p>去年年底，我学习印度从事项目开发，学习印度的软件开发管理方法。一种久违的冲动在心底升起。我在学习过程中和印度的工程师交流过，他们言谈中透着自信。他们给我讲解正在做的软件的测试环境，给我看他们写的单元测试文档。当我看到一个软件模块的单元测试用例有三百多页时，我觉得心里很是沉重。当我第三次踏上这片土地时，我又见到了熟悉的人们，明亮的眼睛，温和的笑容，随意的穿着，风驰电掣的摩托，还有大学校园中穿着拖鞋，手抱书本的年轻人。</p>
+<p>我也见到了我的项目经理，一个个子较高，瘦瘦的年轻人，据说刚从美国回来，已工作了五、六年。我听了心里很高兴，这回要一招一式地学两手。需求分析的时间是一个月，项目经理和我们（实际上代表客户 ）讨论了proposal中的内容，确定每一项都是需要的。然后他把模块大致划分了一下，开始进入计划中的学习阶段。每个人在学习阶段要写出功能描述的胶片，给其他人讲解，不知不觉中，项目组的所有人对项目有了整体的了解。</p>
+<p>他还安排了一些培训，如他们公司的软件开发模型、项目组中各角色的定义，以后及时的培训不断，只要项目组中有需求，他总是把qa或相关的人请来，培训很专业。需求分析完成后提交了一份四十多页的文档，当我看到这份英文文档中我写的部分整整齐齐地列在其中时，我的感觉很复杂，有些喜悦，但更多的是苦涩，我以前怎么就从来没有这样做过需求分析呢。</p>
+<p>在我写文档的过程中，qa给我们培训过srs的写作模板，后来我还是不放心，让他们一个有经验的工程师写了一段，我们再琢磨着照着写。这份srs虽然是多个人合写，但风格一致，内容详实。更为可贵的是，一直到最后，这份需求分析的内容都没有改过，以至于我们没有机会走一下他们的需求更改流程。</p>
+<p>需求分析是项目的第一阶段，第二阶段的开发时间要根据需求分析的结果来确定。当对方的首席技术官（相当于我们业务部的总体组长）来和我们讨论计划时，他们已列出了对每个 模块的代码行数的预测，可能存在的风险。根据他们公司的生产率－－300行/人月，他得出了项目第二阶段需要多少周。</p>
+<p>我们当时就提出了异议：1）公司对该项目需求很急；2）每月300行是否太少；3）我们还有下载的源代码参考。他解释说，300行/人月是使得项目能达到他们质量标准的经验数据，考虑到有源代码参考，生产率最多不能超过350行/人月。</p>
+<p>当他问我们公司的生产率时，我脑袋里转了三个圈，没敢多说，大概六、七百行吧。他沉默了一会儿，然后坚定地说，我们这个计划是建立在确保质量的基础上的，我想你们到印度来开发软件，首先看中的应该是我们印度公司的质量保证。我知道你们不缺乏软件开发人员，你们为什么不选择下载的软件呢。几句话说到了我的痛处，现在国内的弟兄们还在为使用下载软件移植的产品四处奔波呢！</p>
+<p>随后的开发活动有条不紊，我们老老实实地跟着做。系统测试计划、用例，概要设计，集成测试计划、用例，详细设计，单元测试计划、用例，编码，单元测试，集成测试，系统测试。一个完整的v模型开发过程，其中每个过程都有review。当我们对一些设计的方法不太明白时，项目经理给我们发来了相关的资料，我不知道他当时是怎么想的，一些基本的分析、设计方法是十年，甚至二十年前的软件工程书中就讲到的，印度每个计算机专业的人员都是必修这些内容的。而我们除了对一些具体协议的代码很熟之外，对这些常用的方法似乎一无所知。我感到一些羞愧，进城直奔书店，把他给我开列的书找了出来，晚上躺在床上，仔细研读，我仿佛突然又遇到了能给我指点迷津的良师益友。现在印度所已形成了强烈的学习风气。我回来后也推销了700多本书，这些书教我们如何用工程化的方法开发软件，是成为一个软件工程师必读的资料。</p>
+<p>我们的项目经理的计划控制能力很强，当有什么影响到项目计划的事情发生时，如人员辞职、实验室搬家、某一模块预测不准（该模块是我们预测的），他总是采取必要的措施，减少延期，调整计划。刚开始，我们对他们每天上午11点，下午4点下楼喝咖啡还有点意见，后来也跟着喝去了，原来，喝咖啡时的交流非常丰富，从项目管理到设计方法，从技术发展到风土人情，无所不包，对我们互相之间的理解，对团队的气氛很有帮助。我们项目的qa也在适当的时候出现在我们的面前，我们对她的工作只有一些感性认识。她每次参加会议时，手里时常拿着一个check list，项目经理准备相应的资料，回答一些问题，她打着勾，或写着项目经理的解释。她给我们做培训时也很耐心，体现出很好的职业素养，我至今还在怀念她给我们的帮助。</p>
+<p>我从事软件开发已有四个年头了，可我现在仍然不能说自己是个合格的软件工程师，更不用谈什么合格的管理者。我看到一份报道说，瑞士洛桑一权威机构把中国的科技综合竞争力从原来的第十三位调到二十多位，原因是他们调整了一些评估标准，其中有一条是中国合格工程师的可获得性非常低。想着弟兄们熬红的双眼，四处奔波升级的疲惫身影，我有一个强烈的愿望：快把我们自己升级成合格的工程师吧!</p>
+</section><footer class="footer-container"><div class="footer-body"><img src="/img/dubbo_gray.png"/><div class="cols-container"><div class="col col-12"><h3>Disclaimer</h3><p>the disclaimer content</p></div><div class="col col-6"><dl><dt>Documentation</dt><dd><a href="/en-us/docs/introduction.html" target="_self">Overview</a></dd><dd><a href="/en-us/docs/introduction.html" target="_self">Quick start</a></dd><dd><a href="/en-us/docs/dir/introduction.html" target="_self">Developer guide</a></dd></dl></div><div class="col col-6"><dl><dt>Resources</dt><dd><a href="/en-us/blog/index.html" target="_self">Blog</a></dd><dd><a href="/en-us/community/index.html" target="_self">Community</a></dd></dl></div></div><div class="copyright"><span>Copyright © 2018 BurningMyself</span></div></div></footer></div></div>
+	<script src="https://f.alicdn.com/react/15.4.1/react-with-addons.min.js"></script>
+	<script src="https://f.alicdn.com/react/15.4.1/react-dom.min.js"></script>
+	<script>
+		window.rootPath = '';
+  </script>
+	<script src="/build/blogDetail.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/en-us/blog/framework/fwork.json b/en-us/blog/framework/fwork.json
new file mode 100644
index 0000000..b8cd9ab
--- /dev/null
+++ b/en-us/blog/framework/fwork.json
@@ -0,0 +1,6 @@
+{
+  "filename": "fwork.md",
+  "__html": "<h1>走向架构师必备的技能</h1>\n<p>中国有很多年轻人，他们18,9岁或21,2岁，通过自学也写了不少代码，他们有的代码写的很漂亮，一些技术细节相当出众，也很有钻研精神，但是他们被一些错误的认识和观点左右，缺乏对系统，对程序的整体理解能力，这些人，一个网上的朋友说得很好，他们实际fans，压根没有资格称为程序员，但是据我所知，不少小网络公司的Cfans,拿着吓人的工资，做着吓人的项目，项目的结局通常也很吓人。</p>\n<h2>程序员基本素质：</h2>\n<p>作一个真正合格的程序员，或者说就是可以真正合格完成一些代码工作的程序员，应该具有的素质。</p>\n<ol>\n<li>团队精神和协作能力</li>\n</ol>\n<p>把它作为基本素质，并不是不重要，恰恰相反，这是程序员应该具备的最基本的，也是最重要的安身立命之本。把高水平程序员说成独行侠的都是在呓语，任何个人的力量都是有限的，即便如linus这样的天才，也需要通过组成强大的团队来创造奇迹，那些遍布全球的为linux写核心的高手们，没有协作精神是不可想象的。独行侠可以作一些赚钱的小软件发点小财，但是一旦进入一些大系统的研发团队，进入商业化和产品化的开发任务，缺乏这种素质的人就完全不合格了。</p>\n<ol start=\"2\">\n<li>文档习惯</li>\n</ol>\n<p>说高水平程序员从来不写文档的肯定是乳臭未干的毛孩子，良好的文档是正规研发流程中非常重要的环节，作为代码程序员，30％的工作时间写技术文档是很正常的，而作为高级程序员和系统分析员，这个比例还要高很多。缺乏文档，一个软件系统就缺乏生命力，在未来的查错，升级以及模块的复用时就都会遇到极大的麻烦。</p>\n<ol start=\"3\">\n<li>规范化，标准化的代码编写习惯</li>\n</ol>\n<p>作为一些外国知名软件公司的规矩，代码的变量命名，代码内注释格式，甚至嵌套中行缩进的长度和函数间的空行数字都有明确规定，良好的编写习惯，不但有助于代码的移植和纠错，也有助于不同技术人员之间的协作。\nfans叫嚣高水平程序员写的代码旁人从来看不懂，这种叫嚣只能证明他们自己压根不配自称程序员。代码具有良好的可读性，是程序员基本的素质需求。\n再看看整个linux的搭建，没有规范化和标准化的代码习惯，全球的研发协作是绝对不可想象的。</p>\n<ol start=\"4\">\n<li>需求理解能力</li>\n</ol>\n<p>程序员需要理解一个模块的需求，很多小朋友写程序往往只关注一个功能需求，他们把性能指标全部归结到硬件，操作系统和开发环境上，而忽视了本身代码的性能考虑，有人曾经放言说写一个广 告交换程序很简单，这种人从来不知道在百万甚至千万数量级的访问情况下的性能指标是如何实现的，对于这样的程序员，你给他深蓝那套系统，他也做不出太极链的并访能力。性能需求指标中，稳定性，并访支撑能力以及安全性都很重要，作为程序员需要评估该模块在系统运营中所处的环境，将要受到的负荷压力以及各种潜在的危险和恶意攻击的可能性。就这一点，一个成熟的程序员至少需要2到3年的项目研发和跟踪经验才有可能有心得。</p>\n<ol start=\"5\">\n<li>复用性，模块化思维能力</li>\n</ol>\n<p>经常可以听到一些程序员有这样的抱怨，写了几年程序，变成了熟练工，每天都是重复写一些没有任何新意的代码，这其实是中国软件人才最大浪费的地方，一些重复性工作变成了熟练程序员的主要工作，而这些，其实是完全可以避免的。</p>\n<p>复用性设计，模块化思维就是要程序员在完成任何一个功能模块或函数的时候，要多想一些，不要局限在完成当前任务的简单思路上，想想看该模块是否可以脱离这个系统存在，是否可以通过简单的修改参数的方式在其他系统和应用环境下直接引用，这样就能极大避免重复性的开发工作，如果一个软件研发单位和工作组能够在每一次研发过程中都考虑到这些问题，那么程序员就不会在重复性的工作中耽误太多时间，就会有更多时间和精力投入到创新的代码工作中去。</p>\n<p>一些好的程序模块代码，即便是70年代写成的，拿到现在放到一些系统里面作为功能模块都能适合的很好，而现在我看到的是，很多小公司软件一升级或改进就动辄全部代码重写，大部分重复性工作无谓的浪费了时间和精力。</p>\n<ol start=\"6\">\n<li>测试习惯</li>\n</ol>\n<p>作为一些商业化正规化的开发而言，专职的测试工程师是不可少的，但是并不是说有了专职的测试工程师程序员就可以不进行自测；软件研发作为一项工程而言，一个很重要的特点就是问题发现的越早，解决的代价就越低，程序员在每段代码，每个子模块完成后进行认真的测试，就可以尽量将一些潜在的问题最早的发现和解决，这样对整体系统建设的效率和可靠性就有了最大的保证。</p>\n<p>测试工作实际上需要考虑两方面，一方面是正常调用的测试，也就是看程序是否能在正常调用下完成基本功能，这是最基本的测试职责，可惜在很多公司这成了唯一的测试任务，实际上还差的远那；第二方面就是异常调用的测试，比如高压力负荷下的稳定性测试，用户潜在的异常输入情况下的测试，整体系统局部故障情况下该模块受影响状况的测试，频发的异常请求阻塞资源时的模块稳定测试等等。当然并不是程序员要对自己的每段代码都需要进行这种完整测试，但是程序员必须清醒认识自己的代码任务在整体项目中的地位和各种性能需求，有针对性的进行相关测试并尽早发现和解决问题，当然这需要上面提到需求理解能力。</p>\n<ol start=\"7\">\n<li>学习和总结的能力</li>\n</ol>\n<p>程序员是人才很容易被淘汰，很容易落伍的职业，因为一种技术可能仅仅在三两年内具有领先性，程序员如果想安身立命，就必须不断跟进新的技术，学习新的技能。</p>\n<p>善于学习，对于任何职业而言，都是前进所必需的动力，对于程序员，这种要求就更加高了。但是学习也要找对目标，一些小coding有些codingTO就是这样的coding上只是一些Cfans们，他们也津津乐道于他们的学习能力，一会学会了asp，一会儿学会了php，一会儿学会了jsp，他们把这个作为炫耀的资本，盲目的追逐一些肤浅的，表面的东西和名词，做网络程序不懂通讯传输协议，做应用程序不懂中断向量处理，这样的技术人员，不管掌握了多少所谓的新语言，永远不会有质的提高。</p>\n<p>善于总结，也是学习能力的一种体现，每次完 成一个研发任务，完成一段代码，都应当有目的的跟踪该程序的应用状况和用户反馈，随时总结，找到自己的不足，这样逐步提高，一个程序员才可能成长起来。</p>\n<p>一个不具备成长性的程序员，即便眼前看是个高手，建议也不要选用，因为他落伍的时候马上就到了。具备以上全部素质的人，应当说是够格的程序员了，请注意以上的各种素质都不是由IQ决定的，也不是大学某些课本里可以学习到的，需要的仅仅是程序员对自己工作的认识，是一种意识上的问题。</p>\n<h2>高级程序员</h2>\n<p>那么作为高级程序员，以至于系统分析员，也就是对于一个程序项目的设计者而言，除了应该具备上述全部素质之外，还需要具备以下素质：</p>\n<ol>\n<li>需求分析能力</li>\n</ol>\n<p>对于程序员而言，理解需求就可以完成合格的代码，但是对于研发项目的组织和管理者，他们不但要理解客户需求，更多时候还要自行制定一些需求，为什么这么说呢？</p>\n<p>一般而言，进行研发任务，也许是客户提出需求，也许是市场和营销部门提出的需求，这时候对于研发部门，他们看到的不是一个完整的需求，通常而言，该需求仅仅是一些功能上的要求，或者更正规些，可能获得一个完整的用户视图；但是这都不够，因为客户由于非技术因素多一些，他们可能很难提出完整和清晰，或者说专业性的性能需求，但是对于项目组织者和规划者，他必须能够清醒认识到这些需求的存在并在完成 需求分析报告的时候适当的提出，同时要完整和清晰的体现在设计说明书里面，以便于程序员编码时不会失去这些准则。</p>\n<p>程序设计者必须正确理解用户需求所处的环境，并针对性做出需求的分析，举例而言，同样一个软件通过ASP租用方式发布和通过License方式发布，性能需求可能就是有区别的，前者强调的是更好的支撑能力和稳定性，而后者则可能更强调在各种平台下的普适性和安装使用的简捷性。</p>\n<ol start=\"2\">\n<li>项目设计方法和流程处理能力</li>\n</ol>\n<p>程序设计者必须能够掌握不少于两到三种的项目设计方法（比如自顶至下的设计方法，比如快速原型法等等），并能够根据项目需求和资源搭配来选择合适的设计方法进行项 目的整体设计。设计方法上选择不当，就会耽误研发周期，浪费研发资源，甚至影响研发效果。</p>\n<p>一个程序设计者还需要把很多功夫用在流程图的设计和处理上，他需要做数据流图以确立数据词典；他需要加工逻辑流图以形成整体的系统处理流程。一个流程有问题的系统，就算代码多漂亮，每个模块多精致，也不会成为一个好的系统。当然，做好流程分析并选择好项目设计方法，都需要在需求分析能力上具有足够的把握。</p>\n<ol start=\"3\">\n<li>复用设计和模块化分解能力</li>\n</ol>\n<p>这个似乎又是老调重谈，前面基本素质上不是已经说明了这个问题吗？作为一个从事模块任务的程序员，他需要对他所面对的特定功能模块的 复用性进行考虑，而作为一个系统分析人员，他要面对的问题复杂的多，需要对整体系统按照一种模块化的分析能力分解为很多可复用的功能模块和函数，并针对每一模块形成一个独立的设计需求。举个例子，好比是汽车生产，最早每辆汽车都是独立安装的，每个部件都是量身定做的，但是后来不一样了，机器化大生产了，一个汽车厂开始通过流水线来生产汽车，独立部件开始具有一定的复用性，在后来标准化成为大趋势，不同型号，品牌甚至不同厂商的汽车部件也可以进行方便的换装和升级，这时候，汽车生产的效率达到最大化。软件工程也是同样的道理，一个成熟的软件行业，在一些相关项目和系统中，不同的部件是可以随意换装的，比如微软的许多桌面软件，在很多操作模块（如打开文件，保存文件等等）都是复用的同一套功能模块，而这些接口又通过一些类库提供给了桌面应用程序开发者方便挂接，这就是复用化的模块设计明显的一个佐证。</p>\n<p>将一个大型的，错综复杂的应用系统分解成一些相对独立的，具有高度复用性的，并能仅仅依靠几个参数完成数据联系的模块组合，是作为高级程序员和系统分析员一项最重要的工作，合适的项目设计方法，清晰的流程图，是实现这一目标的重要保证。</p>\n<ol start=\"4\">\n<li>整体项目评估能力</li>\n</ol>\n<p>作为系统设计人员，必须能够从全局出发，对项目又整体的清醒认识，比如公司的资源配置是否合理和到位，比如工程进度安排是否能最大化体现效率又不至于无法按期完成。评估项 目整体和各个模块的工作量，评估项目所需的资源，评估项目可能遇到的困难，都需要大量的经验积累，换言之，这是一种不断总结的累计才能达到的境界。在西方一些软件系统设计的带头人都是很年长的，比如4，50岁，甚至更老，他们在编码方面已经远远不如年轻人那样活络，但是就项目评估而言，他们几十年的经验积累就是最重要和宝贵的财富。中国缺这么一代程序员，主要还不是缺那种年纪的程序员，而是那种年纪的程序员基本上都是研究单位作出来的，都不是从专业的产品化软件研发作出来的，他们没有能积累那种产品化研发的经验，这也是没有办法的事情。</p>\n<ol start=\"5\">\n<li>团队组织管理能力</li>\n</ol>\n<p>完成一个项目工程，需要团队的齐心协力，作为项目设计者或研发的主管人，就应当有能力最大化发挥团队的整体力量，技术管理由于其专业性质，不大同于一般的人事管理，因为这里面设计了一些技术性的指标和因素。</p>\n<p>首先是工作的量化，没有量化就很难做到合适的绩效考核，而程序量化又不是简单的代码行数可以计算的，因此要求技术管理人员需要能真正评估一个模块的复杂性和工作量。</p>\n<p>其次是对团队协作模式的调整，一般而言，程序开发的协作通常分为小组进行，小组有主程序员方式的，也有民主方式的，根据程序员之间的能力水平差距，以及根据项目研发的需求，选择合适的组队方式，并能将责权和成员的工作任务紧密结合，这样才能最大发挥组队的效率。</p>\n<p>一个代码水平高的人，未必能成为一个合格的项目研发主管，这方面的能力欠缺往往是容易被忽视的。</p>\n<p>综上可以看到，作为一个主管研发的负责人，一个项目设计者，所需要具备的素质和能力并不是程序代码编写的能力，当然一般情况下，一个程序员通过不断的总结提高达到了这种素质的时候，他所具有的代码编写能力也已经相当不简单了，但是请注意这里面的因果关系，一个高水平的项目设计者通常已经是代码编写相当优秀的人了，但是并不是一个代码相当优秀的程序员就可以胜任项目设计的工作，这里面存在的也不是智商和课本的问题，还是在于一个程序员在积累经验，逐步提升的时候没有意识到应当思考哪方面的东西，没有有意识的就项目的组织和复用设计进行揣摩，没有经常性的文档习惯和总结习惯， 不改变这些，我们的合格的项目设计者还是非常欠缺。</p>\n<p>另外，为防止有无聊的人和我较真，补充一点，本文针对目标是作商业化的软件项目和工程，那些科研机构的编程高手，比如算法高手，比如图象处理高手，他们的工作是研究课题而非直接完成商业软件（当然最终间接成为商业产品，比如微软研究院在作的研究课题），因此他们强调的素质可能是另外的东西，这些人（专家），并不能说是程序员，不能用程序员的标准去衡量。</p>\n<p>最后补充一点东西，一个软件项目研发的设计流程是怎样的呢？以通常标准的设计方法为例，（不过笔者喜欢快速原型法）。</p>\n<ul>\n<li>\n<p>第一个步骤是市场调研，技术和市场要结合才能体现最大价值。</p>\n</li>\n<li>\n<p>第二个步骤是需求分析，这个阶段需要出三样东西，用户视图，数据词典和用户操作手册。用户视图是该软件用户（包括终端用户和管理用户）所能看到的页面样式，这里面包含了很多操作方面的流程和条件。数据词典是指明数据逻辑关系并加以整理的东东，完成了数据词典，数据库的设计就完成了一半多。用户操作手册是指明了操作流程的说明书。</p>\n</li>\n</ul>\n<p>注意，用户操作流程和用户视图是由需求决定的，因此应该在软件设计之前完成，完成这些，就为程序研发提供了约束和准绳，很遗憾太多公司都不是这样做的，因果颠倒，顺序不分，开发工作和实际需求往往因此 产生隔阂脱节的现象。</p>\n<p>需求分析，除了以上工作，笔者以为作为项目设计者应当完整的做出项目的性能需求说明书，因为往往性能需求只有懂技术的人才可能理解，这就需要技术专家和需求方（客户或公司市场部门）能够有真正的沟通和了解。</p>\n<ul>\n<li>\n<p>第三个步骤是概要设计，将系统功能模块初步划分，并给出合理的研发流程和资源要求。作为快速原型设计方法，完成概要设计就可以进入编码阶段了，通常采用这种方法是因为涉及的研发任务属于新领域，技术主管人员一上来无法给出明确的详细设计说明书，但是并不是说详细设计说明书不重要，事实上快速原型法在完成原型代码后，根据评测结果和经验教训的总结，还要重新进行详细设计的步骤。</p>\n</li>\n<li>\n<p>第四个步骤是详细设计，这是考验技术专家设计思维的重 要关卡，详细设计说明书应当把具体的模块以最‘干净’的方式(黑箱结构）提供给编码者，使得系统整体模块化达到最大；一份好的详细设计说明书，可以使编码的复杂性减低到最低，实际上，严格的讲详细设计说明书应当把每个函数的每个参数的定义都精精细细的提供出来，从需求分析到概要设计到完成详细设计说明书，一个软件项目就应当说完成了一半了。换言之，一个大型软件系统在完成了一半的时候，其实还没有开始一行代码工作。那些把作软件的程序员简单理解为写代码的，就从根子上犯了错误了。</p>\n</li>\n<li>\n<p>第五个步骤是编码，在规范化的研发流程中，编码工作在整个项目流程里最多不会超过1/2，通常在1/3的时间，所谓磨刀不误砍柴功，设计过程完成的好，编码效率就会极大提高，编码时不同模块之间的进度协调和协作是最需要小心的，也许一个小模块的问题就可能影响了整体进度，让很多程序员因此被迫停下工作等待，这种问题在很多研发过程中都出现过。编码时的相互沟通和应急的解决手段都是相当重要的，对于程序员而言，bug永远存在，你必须永远面对这个问题，大名鼎鼎的微软，可曾有连续三个月不发补丁的时候吗？从来没有！</p>\n</li>\n<li>\n<p>第六个步骤是测试</p>\n</li>\n</ul>\n<p>测试有很多种：按照测试执行方，可以分为内部测试和外部测试；按照测试范围，可以分为模块测试和整体联调；按照测试条 件，可以分为正常操作情况测试和异常情况测试；按照测试的输入范围，可以分为全覆盖测试和抽样测试。以上都很好理解，不再解释。</p>\n<p>总之，测试同样是项目研发中一个相当重要的步骤，对于一个大型软件，3个月到1年的外部测试都是正常的，因为永远都会又不可预料的问题存在。</p>\n<p>完成测试后，完成验收并完成最后的一些帮助文档，整体项目才算告一段落，当然日后少不了升级，修补等等工作，只要不是想通过一锤子买卖骗钱，就要不停的跟踪软件的运营状况并持续修补升级，知道这个软件被彻底淘汰为止。</p>\n<p>写这些步骤算不上卖弄什么，因为实话讲我手边是一本《软件工程》，在大学里这是计算机专业的必修课程，但是我知道很多程序员似乎从来都只是热衷于什么《30天精通VC》之类的，他们有些和我一样游击队出身，没有正规学过这个专业，还有一些则早就在混够学分后就把这些真正有用的东西还给了老师。</p>\n<p>fans乱嚷嚷，混淆视听，实际上真正的技术专家很少在网上乱发帖子的，如笔者这样不知天高地厚的，其实实在是算不上什么高手，只不过看不惯这种对技术，对程序员的误解和胡说，只好挺身而出，做拨乱反正之言，也希望那些还fans们能认真想想，走到正途上，毕竟那些聪明的头脑还远远没有发挥应有的价值。沉迷于一些错误人士的coding</p>\n<p>从程序员升级到工程师大多数象我这样对软件有浓厚兴趣的人，毕业后义无反顾地走进了企业，开始了程序员的生涯。那时，我们迷恋“大全”、“秘籍”一类的书籍，心中只有代码。当我看到一行行枯燥的代码变成了能够打电话的设备，变成了屏幕上漂亮的表格，变成了动听的音乐，成就感油然而生。我觉得自己也是一个出色的程序员了。在用户的机房中苦熬三昼夜解决软件的bug，也成了一种可以夸耀的资历。五年前的某一天，我把曾经让我兴奋自豪的大量代码和少得可怜的文档移交之后，来到了华为。这里有更多的年轻人，我如鱼得水，可以充分发挥自己的想象力。依然是代码，依然是匆匆地在纸上记下稍纵即逝的灵感（我们把它称作文档），依然是无休止地和bug作斗争。当有一天，一个新来 的同事拿着署着我的大名的文档，小心翼翼地来问我时，我发现自己好象有点不认识它了。我心里有点沮丧，再看看代码，发现文档上记录的一些灵感已面目全非。我当时不知道那位新来的同事感受如何，但我从那时起，好象意识到什么。现在来看，那时的很多事情都是事倍功半。</p>\n<p>去年年底，我学习印度从事项目开发，学习印度的软件开发管理方法。一种久违的冲动在心底升起。我在学习过程中和印度的工程师交流过，他们言谈中透着自信。他们给我讲解正在做的软件的测试环境，给我看他们写的单元测试文档。当我看到一个软件模块的单元测试用例有三百多页时，我觉得心里很是沉重。当我第三次踏上这片土地时，我又见到了熟悉的人们，明亮的眼睛，温和的笑容，随意的穿着，风驰电掣的摩托，还有大学校园中穿着拖鞋，手抱书本的年轻人。</p>\n<p>我也见到了我的项目经理，一个个子较高，瘦瘦的年轻人，据说刚从美国回来，已工作了五、六年。我听了心里很高兴，这回要一招一式地学两手。需求分析的时间是一个月，项目经理和我们（实际上代表客户 ）讨论了proposal中的内容，确定每一项都是需要的。然后他把模块大致划分了一下，开始进入计划中的学习阶段。每个人在学习阶段要写出功能描述的胶片，给其他人讲解，不知不觉中，项目组的所有人对项目有了整体的了解。</p>\n<p>他还安排了一些培训，如他们公司的软件开发模型、项目组中各角色的定义，以后及时的培训不断，只要项目组中有需求，他总是把qa或相关的人请来，培训很专业。需求分析完成后提交了一份四十多页的文档，当我看到这份英文文档中我写的部分整整齐齐地列在其中时，我的感觉很复杂，有些喜悦，但更多的是苦涩，我以前怎么就从来没有这样做过需求分析呢。</p>\n<p>在我写文档的过程中，qa给我们培训过srs的写作模板，后来我还是不放心，让他们一个有经验的工程师写了一段，我们再琢磨着照着写。这份srs虽然是多个人合写，但风格一致，内容详实。更为可贵的是，一直到最后，这份需求分析的内容都没有改过，以至于我们没有机会走一下他们的需求更改流程。</p>\n<p>需求分析是项目的第一阶段，第二阶段的开发时间要根据需求分析的结果来确定。当对方的首席技术官（相当于我们业务部的总体组长）来和我们讨论计划时，他们已列出了对每个 模块的代码行数的预测，可能存在的风险。根据他们公司的生产率－－300行/人月，他得出了项目第二阶段需要多少周。</p>\n<p>我们当时就提出了异议：1）公司对该项目需求很急；2）每月300行是否太少；3）我们还有下载的源代码参考。他解释说，300行/人月是使得项目能达到他们质量标准的经验数据，考虑到有源代码参考，生产率最多不能超过350行/人月。</p>\n<p>当他问我们公司的生产率时，我脑袋里转了三个圈，没敢多说，大概六、七百行吧。他沉默了一会儿，然后坚定地说，我们这个计划是建立在确保质量的基础上的，我想你们到印度来开发软件，首先看中的应该是我们印度公司的质量保证。我知道你们不缺乏软件开发人员，你们为什么不选择下载的软件呢。几句话说到了我的痛处，现在国内的弟兄们还在为使用下载软件移植的产品四处奔波呢！</p>\n<p>随后的开发活动有条不紊，我们老老实实地跟着做。系统测试计划、用例，概要设计，集成测试计划、用例，详细设计，单元测试计划、用例，编码，单元测试，集成测试，系统测试。一个完整的v模型开发过程，其中每个过程都有review。当我们对一些设计的方法不太明白时，项目经理给我们发来了相关的资料，我不知道他当时是怎么想的，一些基本的分析、设计方法是十年，甚至二十年前的软件工程书中就讲到的，印度每个计算机专业的人员都是必修这些内容的。而我们除了对一些具体协议的代码很熟之外，对这些常用的方法似乎一无所知。我感到一些羞愧，进城直奔书店，把他给我开列的书找了出来，晚上躺在床上，仔细研读，我仿佛突然又遇到了能给我指点迷津的良师益友。现在印度所已形成了强烈的学习风气。我回来后也推销了700多本书，这些书教我们如何用工程化的方法开发软件，是成为一个软件工程师必读的资料。</p>\n<p>我们的项目经理的计划控制能力很强，当有什么影响到项目计划的事情发生时，如人员辞职、实验室搬家、某一模块预测不准（该模块是我们预测的），他总是采取必要的措施，减少延期，调整计划。刚开始，我们对他们每天上午11点，下午4点下楼喝咖啡还有点意见，后来也跟着喝去了，原来，喝咖啡时的交流非常丰富，从项目管理到设计方法，从技术发展到风土人情，无所不包，对我们互相之间的理解，对团队的气氛很有帮助。我们项目的qa也在适当的时候出现在我们的面前，我们对她的工作只有一些感性认识。她每次参加会议时，手里时常拿着一个check list，项目经理准备相应的资料，回答一些问题，她打着勾，或写着项目经理的解释。她给我们做培训时也很耐心，体现出很好的职业素养，我至今还在怀念她给我们的帮助。</p>\n<p>我从事软件开发已有四个年头了，可我现在仍然不能说自己是个合格的软件工程师，更不用谈什么合格的管理者。我看到一份报道说，瑞士洛桑一权威机构把中国的科技综合竞争力从原来的第十三位调到二十多位，原因是他们调整了一些评估标准，其中有一条是中国合格工程师的可获得性非常低。想着弟兄们熬红的双眼，四处奔波升级的疲惫身影，我有一个强烈的愿望：快把我们自己升级成合格的工程师吧!</p>\n",
+  "link": "\\en-us\\blog\\framework\\fwork.html",
+  "meta": {}
+}
\ No newline at end of file
diff --git a/en-us/blog/index.html b/en-us/blog/index.html
index 235c429..39bb5b4 100644
--- a/en-us/blog/index.html
+++ b/en-us/blog/index.html
@@ -12,7 +12,7 @@
 	<link rel="stylesheet" href="/build/blog.css" />
 </head>
 <body>
-	<div id="root"><div class="blog-list-page" data-reactroot=""><header class="header-container header-container-normal"><div class="header-body"><a href="/en-us/index.html"><img class="logo" src="/img/dubbo_colorful.png"/></a><div class="search search-normal"><span class="icon-search"></span></div><span class="language-switch language-switch-normal">中</span><div class="header-menu"><img class="header-menu-toggle" src="/img/system/menu_gray.png"/><ul><li class="menu-item menu-item-normal"><a href="/en-us/index.html" target="_self">HOME</a></li><li class="menu-item menu-item-normal"><a href="/en-us/docs/introduction.html" target="_self">DOCS</a></li><li class="menu-item menu-item-normal menu-item-normal-active"><a href="/en-us/blog/index.html" target="_self">BLOG</a></li><li class="menu-item menu-item-normal"><a href="/en-us/community/index.html" target="_self">COMMUNITY</a></li></ul></div></div></header><div class="bar"><div class="bar-body"><img src="/img/system/blog.png" class="front-img"/><span>Blog</span><img src="/img/system/blog.png" class="back-img"/></div></div><section class="blog-container"><div class="col col-18 left-part"><div class="page-slider"><div class="slider-list" style="transform:translateX(-0px);transition:transform 500ms ease;width:0"><div class="slider-page" style="width:0"><div class="slider-item"><a href="/en-us/blog/java/feature.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Java new feature</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Java,Java new feature</p></a></div><div class="slider-item"><a href="/en-us/blog/java/load-class.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Java Class loading mechanism</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Java,Java Class loading mechanism</p></a></div><div class="slider-item"><a href="/en-us/blog/java/orm.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>ORM merit and demerit</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>ORM,Orm merit and demerit</p></a></div><div class="slider-item"><a href="/en-us/blog/python/feature.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Python new feature</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Python,Python new feature</p></a></div><div class="slider-item"><a href="/en-us/blog/python/str_joint.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Python character operation</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Python,Python character operation</p></a></div></div><div class="slider-page" style="width:0"><div class="slider-item"><a href="/en-us/blog/python/syntax_rule.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Python syntax rule</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Python,Python syntax rule</p></a></div><div class="slider-item"><a href="/en-us/blog/sql/data_split.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Data Split</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2019</span></div><p>Data Split</p></a></div></div></div><div class="slider-control"><img class="slider-control-prev slider-control-prev-hidden" src="/img/system/prev.png"/><img class="slider-control-next" src="/img/system/next.png"/></div></div></div><div class="col col-6 right-part"><h4>All posts</h4><ul><li><a href="/en-us/blog/java/feature.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Java new feature</span></a></li><li><a href="/en-us/blog/java/load-class.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Java Class loading mechanism</span></a></li><li><a href="/en-us/blog/java/orm.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>ORM merit and demerit</span></a></li><li><a href="/en-us/blog/python/feature.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Python new feature</span></a></li><li><a href="/en-us/blog/python/str_joint.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Python character operation</span></a></li><li><a href="/en-us/blog/python/syntax_rule.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Python syntax rule</span></a></li><li><a href="/en-us/blog/sql/data_split.html" target="_self"><span>May 12nd，2019<!-- -->  </span><span>Data Split</span></a></li></ul></div></section><footer class="footer-container"><div class="footer-body"><img src="/img/dubbo_gray.png"/><div class="cols-container"><div class="col col-12"><h3>Disclaimer</h3><p>the disclaimer content</p></div><div class="col col-6"><dl><dt>Documentation</dt><dd><a href="/en-us/docs/introduction.html" target="_self">Overview</a></dd><dd><a href="/en-us/docs/introduction.html" target="_self">Quick start</a></dd><dd><a href="/en-us/docs/dir/introduction.html" target="_self">Developer guide</a></dd></dl></div><div class="col col-6"><dl><dt>Resources</dt><dd><a href="/en-us/blog/index.html" target="_self">Blog</a></dd><dd><a href="/en-us/community/index.html" target="_self">Community</a></dd></dl></div></div><div class="copyright"><span>Copyright © 2018 BurningMyself</span></div></div></footer></div></div>
+	<div id="root"><div class="blog-list-page" data-reactroot=""><header class="header-container header-container-normal"><div class="header-body"><a href="/en-us/index.html"><img class="logo" src="/img/dubbo_colorful.png"/></a><div class="search search-normal"><span class="icon-search"></span></div><span class="language-switch language-switch-normal">中</span><div class="header-menu"><img class="header-menu-toggle" src="/img/system/menu_gray.png"/><ul><li class="menu-item menu-item-normal"><a href="/en-us/index.html" target="_self">HOME</a></li><li class="menu-item menu-item-normal"><a href="/en-us/docs/introduction.html" target="_self">DOCS</a></li><li class="menu-item menu-item-normal menu-item-normal-active"><a href="/en-us/blog/index.html" target="_self">BLOG</a></li><li class="menu-item menu-item-normal"><a href="/en-us/community/index.html" target="_self">COMMUNITY</a></li></ul></div></div></header><div class="bar"><div class="bar-body"><img src="/img/system/blog.png" class="front-img"/><span>Blog</span><img src="/img/system/blog.png" class="back-img"/></div></div><section class="blog-container"><div class="col col-18 left-part"><div class="page-slider"><div class="slider-list" style="transform:translateX(-0px);transition:transform 500ms ease;width:0"><div class="slider-page" style="width:0"><div class="slider-item"><a href="/en-us/blog/java/feature.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Java new feature</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Java,Java new feature</p></a></div><div class="slider-item"><a href="/en-us/blog/java/load-class.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Java Class loading mechanism</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Java,Java Class loading mechanism</p></a></div><div class="slider-item"><a href="/en-us/blog/java/orm.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>ORM merit and demerit</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>ORM,Orm merit and demerit</p></a></div><div class="slider-item"><a href="/en-us/blog/python/feature.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Python new feature</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Python,Python new feature</p></a></div><div class="slider-item"><a href="/en-us/blog/python/str_joint.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Python character operation</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Python,Python character operation</p></a></div></div><div class="slider-page" style="width:0"><div class="slider-item"><a href="/en-us/blog/python/syntax_rule.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Python syntax rule</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2018</span></div><p>Python,Python syntax rule</p></a></div><div class="slider-item"><a href="/en-us/blog/sql/data_split.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Data Split</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2019</span></div><p>Data Split</p></a></div><div class="slider-item"><a href="/en-us/blog/framework/split.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Frame split</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2019</span></div><p>Frame split</p></a></div><div class="slider-item"><a href="/en-us/blog/framework/fgb.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Distributed, High concurrency, Multithreading</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2019</span></div><p>Distributed, high concurrency, multithreading</p></a></div><div class="slider-item"><a href="/en-us/blog/framework/aglity.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>How to understand agile development</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2019</span></div><p>How to understand agile development</p></a></div></div><div class="slider-page" style="width:0"><div class="slider-item"><a href="/en-us/blog/framework/fwork.html" target="_self" class="blog-item"><div class="title"><img src="/img/system/docs_normal.png"/><span>Move towards the skills required of an architect</span></div><div class="brief-info"><span class="author">BurningMyself</span><span class="date">May 12nd，2019</span></div><p>Move towards the skills required of an architect</p></a></div></div></div><div class="slider-control"><img class="slider-control-prev slider-control-prev-hidden" src="/img/system/prev.png"/><img class="slider-control-next" src="/img/system/next.png"/></div></div></div><div class="col col-6 right-part"><h4>All posts</h4><ul><li><a href="/en-us/blog/java/feature.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Java new feature</span></a></li><li><a href="/en-us/blog/java/load-class.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Java Class loading mechanism</span></a></li><li><a href="/en-us/blog/java/orm.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>ORM merit and demerit</span></a></li><li><a href="/en-us/blog/python/feature.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Python new feature</span></a></li><li><a href="/en-us/blog/python/str_joint.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Python character operation</span></a></li><li><a href="/en-us/blog/python/syntax_rule.html" target="_self"><span>May 12nd，2018<!-- -->  </span><span>Python syntax rule</span></a></li><li><a href="/en-us/blog/sql/data_split.html" target="_self"><span>May 12nd，2019<!-- -->  </span><span>Data Split</span></a></li><li><a href="/en-us/blog/framework/split.html" target="_self"><span>May 12nd，2019<!-- -->  </span><span>Frame split</span></a></li><li><a href="/en-us/blog/framework/fgb.html" target="_self"><span>May 12nd，2019<!-- -->  </span><span>Distributed, High concurrency, Multithreading</span></a></li><li><a href="/en-us/blog/framework/aglity.html" target="_self"><span>May 12nd，2019<!-- -->  </span><span>How to understand agile development</span></a></li><li><a href="/en-us/blog/framework/fwork.html" target="_self"><span>May 12nd，2019<!-- -->  </span><span>Move towards the skills required of an architect</span></a></li></ul></div></section><footer class="footer-container"><div class="footer-body"><img src="/img/dubbo_gray.png"/><div class="cols-container"><div class="col col-12"><h3>Disclaimer</h3><p>the disclaimer content</p></div><div class="col col-6"><dl><dt>Documentation</dt><dd><a href="/en-us/docs/introduction.html" target="_self">Overview</a></dd><dd><a href="/en-us/docs/introduction.html" target="_self">Quick start</a></dd><dd><a href="/en-us/docs/dir/introduction.html" target="_self">Developer guide</a></dd></dl></div><div class="col col-6"><dl><dt>Resources</dt><dd><a href="/en-us/blog/index.html" target="_self">Blog</a></dd><dd><a href="/en-us/community/index.html" target="_self">Community</a></dd></dl></div></div><div class="copyright"><span>Copyright © 2018 BurningMyself</span></div></div></footer></div></div>
 	<script src="https://f.alicdn.com/react/15.4.1/react-with-addons.min.js"></script>
 	<script src="https://f.alicdn.com/react/15.4.1/react-dom.min.js"></script>
 	<script>
diff --git a/md_json/blog.json b/md_json/blog.json
index 72f48b9..a8d5d0a 100644
--- a/md_json/blog.json
+++ b/md_json/blog.json
@@ -205,11 +205,21 @@
       "link": "\\en-us\\blog\\exp\\tl.html",
       "meta": {}
     },
+    {
+      "filename": "agility.md",
+      "link": "\\en-us\\blog\\framework\\agility.html",
+      "meta": {}
+    },
     {
       "filename": "fgb.md",
       "link": "\\en-us\\blog\\framework\\fgb.html",
       "meta": {}
     },
+    {
+      "filename": "fwork.md",
+      "link": "\\en-us\\blog\\framework\\fwork.html",
+      "meta": {}
+    },
     {
       "filename": "split.md",
       "link": "\\en-us\\blog\\framework\\split.html",
@@ -652,11 +662,21 @@
       "link": "\\zh-cn\\blog\\exp\\tl.html",
       "meta": {}
     },
+    {
+      "filename": "agility.md",
+      "link": "\\zh-cn\\blog\\framework\\agility.html",
+      "meta": {}
+    },
     {
       "filename": "fgb.md",
       "link": "\\zh-cn\\blog\\framework\\fgb.html",
       "meta": {}
     },
+    {
+      "filename": "fwork.md",
+      "link": "\\zh-cn\\blog\\framework\\fwork.html",
+      "meta": {}
+    },
     {
       "filename": "split.md",
       "link": "\\zh-cn\\blog\\framework\\split.html",
diff --git a/site_config/blog.js b/site_config/blog.js
index 661e8f9..6e27e0f 100644
--- a/site_config/blog.js
+++ b/site_config/blog.js
@@ -52,6 +52,34 @@ export default {
         desc: 'Data Split',
         link: '/en-us/blog/sql/data_split.html',
       },  
+      {
+        title: 'Frame split',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: 'Frame split',
+        link: '/en-us/blog/framework/split.html',
+      },  
+      {
+        title: 'Distributed, High concurrency, Multithreading',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: 'Distributed, high concurrency, multithreading',
+        link: '/en-us/blog/framework/fgb.html',
+      },  
+      {
+        title: 'How to understand agile development',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: 'How to understand agile development',
+        link: '/en-us/blog/framework/aglity.html',
+      },  
+      {
+        title: 'Move towards the skills required of an architect',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: 'Move towards the skills required of an architect',
+        link: '/en-us/blog/framework/fwork.html',
+      },  
     ],
   },
   'zh-cn': {
@@ -106,6 +134,34 @@ export default {
         dateStr: 'May 12nd，2019',
         desc: 'Database Split',
         link: '/zh-cn/blog/sql/data_split.html',
+      },  
+      {
+        title: '构架拆分',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: '构架拆分',
+        link: '/en-us/blog/framework/split.html',
+      },  
+      {
+        title: '分布式、高并发、多线程',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: '分布式、高并发、多线程',
+        link: '/en-us/blog/framework/fgb.html',
+      },  
+      {
+        title: '如何理解敏捷开发',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: '如何理解敏捷开发',
+        link: '/en-us/blog/framework/aglity.html',
+      },  
+      {
+        title: '走向架构师必备的技能',
+        author: 'BurningMyself',
+        dateStr: 'August 12nd，2019',
+        desc: '走向架构师必备的技能',
+        link: '/en-us/blog/framework/fwork.html',
       },       
     ],
   },
diff --git a/zh-cn/blog/framework/agility.html b/zh-cn/blog/framework/agility.html
new file mode 100644
index 0000000..1d738de
--- /dev/null
+++ b/zh-cn/blog/framework/agility.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+	<meta name="keywords" content="agility" />
+	<meta name="description" content="agility" />
+	<!-- 网页标签标题 -->
+	<title>agility</title>
+	<link rel="shortcut icon" href="/img/docsite.ico"/>
+	<link rel="stylesheet" href="/build/blogDetail.css" />
+</head>
+<body>
+	<div id="root"><div class="blog-detail-page" data-reactroot=""><header class="header-container header-container-normal"><div class="header-body"><a href="/zh-cn/index.html"><img class="logo" src="/img/dubbo_colorful.png"/></a><div class="search search-normal"><span class="icon-search"></span></div><span class="language-switch language-switch-normal">En</span><div class="header-menu"><img class="header-menu-toggle" src="/img/system/menu_gray.png"/><ul><li class="menu-item menu-item-normal"><a href="/zh-cn/index.html" target="_self">首页</a></li><li class="menu-item menu-item-normal"><a href="/zh-cn/docs/introduction.html" target="_self">文档</a></li><li class="menu-item menu-item-normal menu-item-normal-active"><a href="/zh-cn/blog/index.html" target="_self">博客</a></li><li class="menu-item menu-item-normal"><a href="/zh-cn/community/index.html" target="_self">社区</a></li></ul></div></div></header><section class="blog-content markdown-body"><h1>如何理解敏捷开发</h1>
+<h2>为什么要敏捷开发</h2>
+<p>“没有人喜欢敏捷，但我们不得不敏捷。就像没有人喜欢工作，但你必须工作。”这是我经常用来调侃敏捷的一句话。试想一下，拿到一份完整详尽的需求文档，逐个功能Coding，测试部署上线。不需要再次确认需求，不会有人打断思路。没有需求更改，只要自己不犯错，不存在推倒重来这才是大部分开发人员最舒服的工作方式吧，简直太完美了。但它很像瀑布，一点都不敏捷。既然我们喜欢的工作方式是传统的、瀑布的，为什么要敏捷？这还不都是市场环境逼的。今天的市场向我们提出了三个问题：</p>
+<h2>01如何做出真正满足用户需求的产品？</h2>
+<p>我不确定这世上是否有人可以做到，他所做出的全部决定都是对的。但绝大多数人是无法一次性做出真正满足用户需求的产品的。我们无法预测未来，我们必须通过一次次的测试，去寻找用户需要的产品是什么？想要更快地获得好的产品，必须迅速将产品推向市场，快速试验，避免走弯路。</p>
+<h2>02如何满足不断变化的用户需求？</h2>
+<p>今天所有的事情的都在快速变化，用户的需求也在变化。毫不夸张地说，我们正在全力开发的一些功能，当它们上线的时候，我们的用户已经不再需要了。我们没有办法让一切不变，我们只能选择去拥抱变化。</p>
+<h2>03如何同时满足不同层次用户的需求？</h2>
+<p>过去我们的产品会遵循产品生命周期，早期追求新奇的尝鲜者，中期普通大众，后期落后者。今天，产品的生命周期变化非常地快，我们可能会同时面对尝鲜者、普通大众、落后者，不同的用户类型的需求是不一样的，你如何满足他们？我们必须快速响应，没法快速响应，就没法留住用户，没有用户就没有一切。迅速将产品推向市场，拥抱变化、快速响应。今天的市场向所有的从业者提出了一个要求：拥有应对快速变化的需求的软件开发能力。而敏捷就是赋予团队应对快速变化的需求的软件开发能力的方法，而这就是敏捷流行的原因。</p>
+<h2>什么是敏捷开发</h2>
+<p>敏捷绝非某一种特定的开发方法，它只是一种应对快速变化的需求的一种软件开发能力。敏捷本身只包含了《敏捷软件开发宣言》和《敏捷软件的十二条原则》两份文档。敏捷相信，只要符合这两份文档的开发方法，就能让开发团队拥有应对快速变化需求的能力，这样的开发方法都叫做敏捷开发方法。</p>
+<h2>最流行的敏捷开发方式是什么</h2>
+<p>敏捷开发的方法有很多：ASD、AUP、DSDM、XP、FDD、Kanban、RAD、Scrum。目前国内最流行的应属Scrum。Scrum本意是指橄榄球运动中的“带球过人”，它可以解决非常复杂的项目，并且能高效并创造性地交付高价值的产品。Scrum包含3个角色、3个工件、5个价值观、5个事件 <a href="https://www.scrum.org/">详情https://www.scrum.org</a>。相比其他敏捷方法，Scrum既不简单又不复杂。它有完善的指南，你可以按照指南，轻易在团队内推广尝试。但想要实践好Scrum，又需要很好的技巧。这种易上手难精通的方法，特别适合培训机构。所以近几年，关于Scrum的培训机构遍地都是。可以说，在Scrum流行这件事上，这些培训机构做了很大的贡献。</p>
+<h2>如何实施Scrum</h2>
+<p>在团队中实施敏捷开发是一个很有挑战性的工作，尤其是Scrum这种描述比较详细、有很多规则的方法。</p>
+<p>**如果你打算把所有人召集到一起，宣布我们要实施敏捷开发Scrum，然后就照着Scrum的描述开发方法直接实施，那么，你离失败不远了。**想要实施好Scrum，你必须一步步来，一点一点改变团队的习惯，当一项新制度已经变成本能之后，再推行下一项制度。</p>
+<h3>&gt;&gt;&gt;&gt;第一步，先把团队的开发任务可视化。</h3>
+<p>你可以用一块白板，让团队成员把所有的开发任务都用便签写好放上去，也可以找一个专业的看板工具。我推荐日事清，当所有任务都在看板上，尽收眼底，那种感觉还是很棒的。团队中每个人的工作都会被所有人看到，会形成一种无形的监督。</p>
+<h3>&gt;&gt;&gt;&gt;第二步，引入站会制度。</h3>
+<p>当团队所有人的任务都在看板后，这些任务的状态是需要有人更新的。无论是专人更新，还是每个人自己更新，都会出现忘记更新，更新不及时的情况。这时，就可以顺势引入站会制度了。每天上班的时候，或者每天下班的时候，所有人站到一起，花15分钟，说一下自己做了什么，准备做什么，所有人一起把看板更新了。</p>
+<h3>&gt;&gt;&gt;&gt;第三步，引入回顾会议</h3>
+<p>当站会制度成熟后，就可以挑一个版本发布的日子。等版本发布后，把团队成员叫到一起，开一个回顾会。让团队成员对这个版本开发的情况做个总结，同时可以让大家用便签把这个开发版本遇到的问题、不满写下来。针对这些问题不满，大家一起讨论一些改进方案。</p>
+<h3>&gt;&gt;&gt;&gt;第四步，引入计划会议</h3>
+<p>如果再开回顾会的时候，有人提出需求不清，拆解不够细致，工时估算不准之类的问题，那你真是太幸运了。碰到这种情况，你顺势提出这个制度：每个版本开发前，产品经理要和团队人员开个会，一起逐条对需求。产品经理要向团队解释每个需求，并且对团队提出的疑问进行解释和澄清。开发团队要将需求分解成任务，估算工时，最终形成一个开发清单。</p>
+<h3>&gt;&gt;&gt;&gt;第五步，引入评审会议</h3>
+<p>当计划会成功开过几次之后，就可以考虑引入评审会了。你可以在某个重大功能发布的时候，把所有项目相关的人员召集起来，向大家展示团队做了哪些了不起的功能，也可以和大家讨论讨论还可以做哪些优化。</p>
+<h3>&gt;&gt;&gt;&gt;第六步，宣布引入Scrum</h3>
+<p>当整个流程都跑顺以后，就可以在某次全体会议上，提出我们要实施Scrum了。你需要任命PO、SM，对团队培训Scrum知识，讲解Scrum的价值观。</p>
+<h2>实施敏捷开发会面临怎样的挑战</h2>
+<p>1.团队成员对变化的恐惧</p>
+<p>实施Scrum最大的挑战来自内部，来自团队对变化的恐惧。每个团队在运营一段时间后都会形成固有的默契和习惯，引入Scrum必然会打破这种习惯。这会让团队很不舒服，团队也会抵制，甚至是反抗。而且实施敏捷的过程，一定不是一帆风顺的，尤其是实施敏捷的早期阶段，不仅不会对团队产生太大的价值，反而会引起混乱。所以，在实施敏捷的过程中，千万要小心，每次只改变一点点，敏捷地完成敏捷。</p>
+<p>2.组织人员的专业化水</p>
+<p>平敏捷并不会直接提高团队的专业化水平，反而对团队专业化水平有一定的要求。必要的专业分工、合适的专业能力是必须的。敏捷会让开发整个流程持续运转，当某一个环节专业化能力出现问题的时候，会极大地导致整个流程运转停滞。平时团队中的问题会在敏捷中快速暴露。一旦出现专业水平问题，要及时解决，补充人员，或者帮助其提高能力。即使问题并不严重，也要在最短的时间解决，否则会影响团队对敏捷的信心。</p>
+<p>3.产品经理这个组织Bug</p>
+<p>国内在实施Scrum的时候经常会碰到的问题就是团队中会有产品经理这个角色。</p>
+<p><strong>一般的处理方法是产品经理当PO</strong>，但PO是需要领导开发团队的。国内的产品经理往往不是技术出身，领导开发团队会出很多问题，所以产品经理并不适合当PO。</p>
+<p><strong>另一种做法是产品经理做利益相关者</strong>，这种做法更不靠谱，利益相关者离团队太远，会出现无法及时响应的问题，时间长了也会导致产品和开发之间关系冷漠，出现隔阂。我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>
+<p>我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>
+<p>另外腾讯企业微信里<a href="https://www.tapd.cn"><strong>TAPD</strong></a>也是不错的</p>
+</section><footer class="footer-container"><div class="footer-body"><img src="/img/dubbo_gray.png"/><div class="cols-container"><div class="col col-12"><h3>免责声明</h3><p>免责声明的具体内容</p></div><div class="col col-6"><dl><dt>文档</dt><dd><a href="/zh-cn/docs/introduction.html" target="_self">概览</a></dd><dd><a href="/zh-cn/docs/introduction.html" target="_self">快速开始</a></dd><dd><a href="/zh-cn/docs/dir/introduction.html" target="_self">开发者指南</a></dd></dl></div><div class="col col-6"><dl><dt>资源</dt><dd><a href="/zh-cn/blog/index.html" target="_self">博客</a></dd><dd><a href="/zh-cn/community/index.html" target="_self">社区</a></dd></dl></div></div><div class="copyright"><span>Copyright © 2018 BurningMyself</span></div></div></footer></div></div>
+	<script src="https://f.alicdn.com/react/15.4.1/react-with-addons.min.js"></script>
+	<script src="https://f.alicdn.com/react/15.4.1/react-dom.min.js"></script>
+	<script>
+		window.rootPath = '';
+  </script>
+	<script src="/build/blogDetail.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/zh-cn/blog/framework/agility.json b/zh-cn/blog/framework/agility.json
new file mode 100644
index 0000000..ae869ca
--- /dev/null
+++ b/zh-cn/blog/framework/agility.json
@@ -0,0 +1,6 @@
+{
+  "filename": "agility.md",
+  "__html": "<h1>如何理解敏捷开发</h1>\n<h2>为什么要敏捷开发</h2>\n<p>“没有人喜欢敏捷，但我们不得不敏捷。就像没有人喜欢工作，但你必须工作。”这是我经常用来调侃敏捷的一句话。试想一下，拿到一份完整详尽的需求文档，逐个功能Coding，测试部署上线。不需要再次确认需求，不会有人打断思路。没有需求更改，只要自己不犯错，不存在推倒重来这才是大部分开发人员最舒服的工作方式吧，简直太完美了。但它很像瀑布，一点都不敏捷。既然我们喜欢的工作方式是传统的、瀑布的，为什么要敏捷？这还不都是市场环境逼的。今天的市场向我们提出了三个问题：</p>\n<h2>01如何做出真正满足用户需求的产品？</h2>\n<p>我不确定这世上是否有人可以做到，他所做出的全部决定都是对的。但绝大多数人是无法一次性做出真正满足用户需求的产品的。我们无法预测未来，我们必须通过一次次的测试，去寻找用户需要的产品是什么？想要更快地获得好的产品，必须迅速将产品推向市场，快速试验，避免走弯路。</p>\n<h2>02如何满足不断变化的用户需求？</h2>\n<p>今天所有的事情的都在快速变化，用户的需求也在变化。毫不夸张地说，我们正在全力开发的一些功能，当它们上线的时候，我们的用户已经不再需要了。我们没有办法让一切不变，我们只能选择去拥抱变化。</p>\n<h2>03如何同时满足不同层次用户的需求？</h2>\n<p>过去我们的产品会遵循产品生命周期，早期追求新奇的尝鲜者，中期普通大众，后期落后者。今天，产品的生命周期变化非常地快，我们可能会同时面对尝鲜者、普通大众、落后者，不同的用户类型的需求是不一样的，你如何满足他们？我们必须快速响应，没法快速响应，就没法留住用户，没有用户就没有一切。迅速将产品推向市场，拥抱变化、快速响应。今天的市场向所有的从业者提出了一个要求：拥有应对快速变化的需求的软件开发能力。而敏捷就是赋予团队应对快速变化的需求的软件开发能力的方法，而这就是敏捷流行的原因。</p>\n<h2>什么是敏捷开发</h2>\n<p>敏捷绝非某一种特定的开发方法，它只是一种应对快速变化的需求的一种软件开发能力。敏捷本身只包含了《敏捷软件开发宣言》和《敏捷软件的十二条原则》两份文档。敏捷相信，只要符合这两份文档的开发方法，就能让开发团队拥有应对快速变化需求的能力，这样的开发方法都叫做敏捷开发方法。</p>\n<h2>最流行的敏捷开发方式是什么</h2>\n<p>敏捷开发的方法有很多：ASD、AUP、DSDM、XP、FDD、Kanban、RAD、Scrum。目前国内最流行的应属Scrum。Scrum本意是指橄榄球运动中的“带球过人”，它可以解决非常复杂的项目，并且能高效并创造性地交付高价值的产品。Scrum包含3个角色、3个工件、5个价值观、5个事件 <a href=\"https://www.scrum.org/\">详情https://www.scrum.org</a>。相比其他敏捷方法，Scrum既不简单又不复杂。它有完善的指南，你可以按照指南，轻易在团队内推广尝试。但想要实践好Scrum，又需要很好的技巧。这种易上手难精通的方法，特别适合培训机构。所以近几年，关于Scrum的培训机构遍地都是。可以说，在Scrum流行这件事上，这些培训机构做了很大的贡献。</p>\n<h2>如何实施Scrum</h2>\n<p>在团队中实施敏捷开发是一个很有挑战性的工作，尤其是Scrum这种描述比较详细、有很多规则的方法。</p>\n<p>**如果你打算把所有人召集到一起，宣布我们要实施敏捷开发Scrum，然后就照着Scrum的描述开发方法直接实施，那么，你离失败不远了。**想要实施好Scrum，你必须一步步来，一点一点改变团队的习惯，当一项新制度已经变成本能之后，再推行下一项制度。</p>\n<h3>&gt;&gt;&gt;&gt;第一步，先把团队的开发任务可视化。</h3>\n<p>你可以用一块白板，让团队成员把所有的开发任务都用便签写好放上去，也可以找一个专业的看板工具。我推荐日事清，当所有任务都在看板上，尽收眼底，那种感觉还是很棒的。团队中每个人的工作都会被所有人看到，会形成一种无形的监督。</p>\n<h3>&gt;&gt;&gt;&gt;第二步，引入站会制度。</h3>\n<p>当团队所有人的任务都在看板后，这些任务的状态是需要有人更新的。无论是专人更新，还是每个人自己更新，都会出现忘记更新，更新不及时的情况。这时，就可以顺势引入站会制度了。每天上班的时候，或者每天下班的时候，所有人站到一起，花15分钟，说一下自己做了什么，准备做什么，所有人一起把看板更新了。</p>\n<h3>&gt;&gt;&gt;&gt;第三步，引入回顾会议</h3>\n<p>当站会制度成熟后，就可以挑一个版本发布的日子。等版本发布后，把团队成员叫到一起，开一个回顾会。让团队成员对这个版本开发的情况做个总结，同时可以让大家用便签把这个开发版本遇到的问题、不满写下来。针对这些问题不满，大家一起讨论一些改进方案。</p>\n<h3>&gt;&gt;&gt;&gt;第四步，引入计划会议</h3>\n<p>如果再开回顾会的时候，有人提出需求不清，拆解不够细致，工时估算不准之类的问题，那你真是太幸运了。碰到这种情况，你顺势提出这个制度：每个版本开发前，产品经理要和团队人员开个会，一起逐条对需求。产品经理要向团队解释每个需求，并且对团队提出的疑问进行解释和澄清。开发团队要将需求分解成任务，估算工时，最终形成一个开发清单。</p>\n<h3>&gt;&gt;&gt;&gt;第五步，引入评审会议</h3>\n<p>当计划会成功开过几次之后，就可以考虑引入评审会了。你可以在某个重大功能发布的时候，把所有项目相关的人员召集起来，向大家展示团队做了哪些了不起的功能，也可以和大家讨论讨论还可以做哪些优化。</p>\n<h3>&gt;&gt;&gt;&gt;第六步，宣布引入Scrum</h3>\n<p>当整个流程都跑顺以后，就可以在某次全体会议上，提出我们要实施Scrum了。你需要任命PO、SM，对团队培训Scrum知识，讲解Scrum的价值观。</p>\n<h2>实施敏捷开发会面临怎样的挑战</h2>\n<p>1.团队成员对变化的恐惧</p>\n<p>实施Scrum最大的挑战来自内部，来自团队对变化的恐惧。每个团队在运营一段时间后都会形成固有的默契和习惯，引入Scrum必然会打破这种习惯。这会让团队很不舒服，团队也会抵制，甚至是反抗。而且实施敏捷的过程，一定不是一帆风顺的，尤其是实施敏捷的早期阶段，不仅不会对团队产生太大的价值，反而会引起混乱。所以，在实施敏捷的过程中，千万要小心，每次只改变一点点，敏捷地完成敏捷。</p>\n<p>2.组织人员的专业化水</p>\n<p>平敏捷并不会直接提高团队的专业化水平，反而对团队专业化水平有一定的要求。必要的专业分工、合适的专业能力是必须的。敏捷会让开发整个流程持续运转，当某一个环节专业化能力出现问题的时候，会极大地导致整个流程运转停滞。平时团队中的问题会在敏捷中快速暴露。一旦出现专业水平问题，要及时解决，补充人员，或者帮助其提高能力。即使问题并不严重，也要在最短的时间解决，否则会影响团队对敏捷的信心。</p>\n<p>3.产品经理这个组织Bug</p>\n<p>国内在实施Scrum的时候经常会碰到的问题就是团队中会有产品经理这个角色。</p>\n<p><strong>一般的处理方法是产品经理当PO</strong>，但PO是需要领导开发团队的。国内的产品经理往往不是技术出身，领导开发团队会出很多问题，所以产品经理并不适合当PO。</p>\n<p><strong>另一种做法是产品经理做利益相关者</strong>，这种做法更不靠谱，利益相关者离团队太远，会出现无法及时响应的问题，时间长了也会导致产品和开发之间关系冷漠，出现隔阂。我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>\n<p>我们目前的做法是尝试是引入一个非官方版本的Scrum（Scrum 3.0），他将PO拆分成了业务拥有者（BO）和团队队长（TC）。产品经理担任BO，开发经理担任TC，目前看效果还不错</p>\n<p>另外腾讯企业微信里<a href=\"https://www.tapd.cn\"><strong>TAPD</strong></a>也是不错的</p>\n",
+  "link": "\\zh-cn\\blog\\framework\\agility.html",
+  "meta": {}
+}
\ No newline at end of file
diff --git a/zh-cn/blog/framework/fwork.html b/zh-cn/blog/framework/fwork.html
new file mode 100644
index 0000000..f6e5963
--- /dev/null
+++ b/zh-cn/blog/framework/fwork.html
@@ -0,0 +1,135 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+	<meta name="keywords" content="fwork" />
+	<meta name="description" content="fwork" />
+	<!-- 网页标签标题 -->
+	<title>fwork</title>
+	<link rel="shortcut icon" href="/img/docsite.ico"/>
+	<link rel="stylesheet" href="/build/blogDetail.css" />
+</head>
+<body>
+	<div id="root"><div class="blog-detail-page" data-reactroot=""><header class="header-container header-container-normal"><div class="header-body"><a href="/zh-cn/index.html"><img class="logo" src="/img/dubbo_colorful.png"/></a><div class="search search-normal"><span class="icon-search"></span></div><span class="language-switch language-switch-normal">En</span><div class="header-menu"><img class="header-menu-toggle" src="/img/system/menu_gray.png"/><ul><li class="menu-item menu-item-normal"><a href="/zh-cn/index.html" target="_self">首页</a></li><li class="menu-item menu-item-normal"><a href="/zh-cn/docs/introduction.html" target="_self">文档</a></li><li class="menu-item menu-item-normal menu-item-normal-active"><a href="/zh-cn/blog/index.html" target="_self">博客</a></li><li class="menu-item menu-item-normal"><a href="/zh-cn/community/index.html" target="_self">社区</a></li></ul></div></div></header><section class="blog-content markdown-body"><h1>走向架构师必备的技能</h1>
+<p>中国有很多年轻人，他们18,9岁或21,2岁，通过自学也写了不少代码，他们有的代码写的很漂亮，一些技术细节相当出众，也很有钻研精神，但是他们被一些错误的认识和观点左右，缺乏对系统，对程序的整体理解能力，这些人，一个网上的朋友说得很好，他们实际fans，压根没有资格称为程序员，但是据我所知，不少小网络公司的Cfans,拿着吓人的工资，做着吓人的项目，项目的结局通常也很吓人。</p>
+<h2>程序员基本素质：</h2>
+<p>作一个真正合格的程序员，或者说就是可以真正合格完成一些代码工作的程序员，应该具有的素质。</p>
+<ol>
+<li>团队精神和协作能力</li>
+</ol>
+<p>把它作为基本素质，并不是不重要，恰恰相反，这是程序员应该具备的最基本的，也是最重要的安身立命之本。把高水平程序员说成独行侠的都是在呓语，任何个人的力量都是有限的，即便如linus这样的天才，也需要通过组成强大的团队来创造奇迹，那些遍布全球的为linux写核心的高手们，没有协作精神是不可想象的。独行侠可以作一些赚钱的小软件发点小财，但是一旦进入一些大系统的研发团队，进入商业化和产品化的开发任务，缺乏这种素质的人就完全不合格了。</p>
+<ol start="2">
+<li>文档习惯</li>
+</ol>
+<p>说高水平程序员从来不写文档的肯定是乳臭未干的毛孩子，良好的文档是正规研发流程中非常重要的环节，作为代码程序员，30％的工作时间写技术文档是很正常的，而作为高级程序员和系统分析员，这个比例还要高很多。缺乏文档，一个软件系统就缺乏生命力，在未来的查错，升级以及模块的复用时就都会遇到极大的麻烦。</p>
+<ol start="3">
+<li>规范化，标准化的代码编写习惯</li>
+</ol>
+<p>作为一些外国知名软件公司的规矩，代码的变量命名，代码内注释格式，甚至嵌套中行缩进的长度和函数间的空行数字都有明确规定，良好的编写习惯，不但有助于代码的移植和纠错，也有助于不同技术人员之间的协作。
+fans叫嚣高水平程序员写的代码旁人从来看不懂，这种叫嚣只能证明他们自己压根不配自称程序员。代码具有良好的可读性，是程序员基本的素质需求。
+再看看整个linux的搭建，没有规范化和标准化的代码习惯，全球的研发协作是绝对不可想象的。</p>
+<ol start="4">
+<li>需求理解能力</li>
+</ol>
+<p>程序员需要理解一个模块的需求，很多小朋友写程序往往只关注一个功能需求，他们把性能指标全部归结到硬件，操作系统和开发环境上，而忽视了本身代码的性能考虑，有人曾经放言说写一个广 告交换程序很简单，这种人从来不知道在百万甚至千万数量级的访问情况下的性能指标是如何实现的，对于这样的程序员，你给他深蓝那套系统，他也做不出太极链的并访能力。性能需求指标中，稳定性，并访支撑能力以及安全性都很重要，作为程序员需要评估该模块在系统运营中所处的环境，将要受到的负荷压力以及各种潜在的危险和恶意攻击的可能性。就这一点，一个成熟的程序员至少需要2到3年的项目研发和跟踪经验才有可能有心得。</p>
+<ol start="5">
+<li>复用性，模块化思维能力</li>
+</ol>
+<p>经常可以听到一些程序员有这样的抱怨，写了几年程序，变成了熟练工，每天都是重复写一些没有任何新意的代码，这其实是中国软件人才最大浪费的地方，一些重复性工作变成了熟练程序员的主要工作，而这些，其实是完全可以避免的。</p>
+<p>复用性设计，模块化思维就是要程序员在完成任何一个功能模块或函数的时候，要多想一些，不要局限在完成当前任务的简单思路上，想想看该模块是否可以脱离这个系统存在，是否可以通过简单的修改参数的方式在其他系统和应用环境下直接引用，这样就能极大避免重复性的开发工作，如果一个软件研发单位和工作组能够在每一次研发过程中都考虑到这些问题，那么程序员就不会在重复性的工作中耽误太多时间，就会有更多时间和精力投入到创新的代码工作中去。</p>
+<p>一些好的程序模块代码，即便是70年代写成的，拿到现在放到一些系统里面作为功能模块都能适合的很好，而现在我看到的是，很多小公司软件一升级或改进就动辄全部代码重写，大部分重复性工作无谓的浪费了时间和精力。</p>
+<ol start="6">
+<li>测试习惯</li>
+</ol>
+<p>作为一些商业化正规化的开发而言，专职的测试工程师是不可少的，但是并不是说有了专职的测试工程师程序员就可以不进行自测；软件研发作为一项工程而言，一个很重要的特点就是问题发现的越早，解决的代价就越低，程序员在每段代码，每个子模块完成后进行认真的测试，就可以尽量将一些潜在的问题最早的发现和解决，这样对整体系统建设的效率和可靠性就有了最大的保证。</p>
+<p>测试工作实际上需要考虑两方面，一方面是正常调用的测试，也就是看程序是否能在正常调用下完成基本功能，这是最基本的测试职责，可惜在很多公司这成了唯一的测试任务，实际上还差的远那；第二方面就是异常调用的测试，比如高压力负荷下的稳定性测试，用户潜在的异常输入情况下的测试，整体系统局部故障情况下该模块受影响状况的测试，频发的异常请求阻塞资源时的模块稳定测试等等。当然并不是程序员要对自己的每段代码都需要进行这种完整测试，但是程序员必须清醒认识自己的代码任务在整体项目中的地位和各种性能需求，有针对性的进行相关测试并尽早发现和解决问题，当然这需要上面提到需求理解能力。</p>
+<ol start="7">
+<li>学习和总结的能力</li>
+</ol>
+<p>程序员是人才很容易被淘汰，很容易落伍的职业，因为一种技术可能仅仅在三两年内具有领先性，程序员如果想安身立命，就必须不断跟进新的技术，学习新的技能。</p>
+<p>善于学习，对于任何职业而言，都是前进所必需的动力，对于程序员，这种要求就更加高了。但是学习也要找对目标，一些小coding有些codingTO就是这样的coding上只是一些Cfans们，他们也津津乐道于他们的学习能力，一会学会了asp，一会儿学会了php，一会儿学会了jsp，他们把这个作为炫耀的资本，盲目的追逐一些肤浅的，表面的东西和名词，做网络程序不懂通讯传输协议，做应用程序不懂中断向量处理，这样的技术人员，不管掌握了多少所谓的新语言，永远不会有质的提高。</p>
+<p>善于总结，也是学习能力的一种体现，每次完 成一个研发任务，完成一段代码，都应当有目的的跟踪该程序的应用状况和用户反馈，随时总结，找到自己的不足，这样逐步提高，一个程序员才可能成长起来。</p>
+<p>一个不具备成长性的程序员，即便眼前看是个高手，建议也不要选用，因为他落伍的时候马上就到了。具备以上全部素质的人，应当说是够格的程序员了，请注意以上的各种素质都不是由IQ决定的，也不是大学某些课本里可以学习到的，需要的仅仅是程序员对自己工作的认识，是一种意识上的问题。</p>
+<h2>高级程序员</h2>
+<p>那么作为高级程序员，以至于系统分析员，也就是对于一个程序项目的设计者而言，除了应该具备上述全部素质之外，还需要具备以下素质：</p>
+<ol>
+<li>需求分析能力</li>
+</ol>
+<p>对于程序员而言，理解需求就可以完成合格的代码，但是对于研发项目的组织和管理者，他们不但要理解客户需求，更多时候还要自行制定一些需求，为什么这么说呢？</p>
+<p>一般而言，进行研发任务，也许是客户提出需求，也许是市场和营销部门提出的需求，这时候对于研发部门，他们看到的不是一个完整的需求，通常而言，该需求仅仅是一些功能上的要求，或者更正规些，可能获得一个完整的用户视图；但是这都不够，因为客户由于非技术因素多一些，他们可能很难提出完整和清晰，或者说专业性的性能需求，但是对于项目组织者和规划者，他必须能够清醒认识到这些需求的存在并在完成 需求分析报告的时候适当的提出，同时要完整和清晰的体现在设计说明书里面，以便于程序员编码时不会失去这些准则。</p>
+<p>程序设计者必须正确理解用户需求所处的环境，并针对性做出需求的分析，举例而言，同样一个软件通过ASP租用方式发布和通过License方式发布，性能需求可能就是有区别的，前者强调的是更好的支撑能力和稳定性，而后者则可能更强调在各种平台下的普适性和安装使用的简捷性。</p>
+<ol start="2">
+<li>项目设计方法和流程处理能力</li>
+</ol>
+<p>程序设计者必须能够掌握不少于两到三种的项目设计方法（比如自顶至下的设计方法，比如快速原型法等等），并能够根据项目需求和资源搭配来选择合适的设计方法进行项 目的整体设计。设计方法上选择不当，就会耽误研发周期，浪费研发资源，甚至影响研发效果。</p>
+<p>一个程序设计者还需要把很多功夫用在流程图的设计和处理上，他需要做数据流图以确立数据词典；他需要加工逻辑流图以形成整体的系统处理流程。一个流程有问题的系统，就算代码多漂亮，每个模块多精致，也不会成为一个好的系统。当然，做好流程分析并选择好项目设计方法，都需要在需求分析能力上具有足够的把握。</p>
+<ol start="3">
+<li>复用设计和模块化分解能力</li>
+</ol>
+<p>这个似乎又是老调重谈，前面基本素质上不是已经说明了这个问题吗？作为一个从事模块任务的程序员，他需要对他所面对的特定功能模块的 复用性进行考虑，而作为一个系统分析人员，他要面对的问题复杂的多，需要对整体系统按照一种模块化的分析能力分解为很多可复用的功能模块和函数，并针对每一模块形成一个独立的设计需求。举个例子，好比是汽车生产，最早每辆汽车都是独立安装的，每个部件都是量身定做的，但是后来不一样了，机器化大生产了，一个汽车厂开始通过流水线来生产汽车，独立部件开始具有一定的复用性，在后来标准化成为大趋势，不同型号，品牌甚至不同厂商的汽车部件也可以进行方便的换装和升级，这时候，汽车生产的效率达到最大化。软件工程也是同样的道理，一个成熟的软件行业，在一些相关项目和系统中，不同的部件是可以随意换装的，比如微软的许多桌面软件，在很多操作模块（如打开文件，保存文件等等）都是复用的同一套功能模块，而这些接口又通过一些类库提供给了桌面应用程序开发者方便挂接，这就是复用化的模块设计明显的一个佐证。</p>
+<p>将一个大型的，错综复杂的应用系统分解成一些相对独立的，具有高度复用性的，并能仅仅依靠几个参数完成数据联系的模块组合，是作为高级程序员和系统分析员一项最重要的工作，合适的项目设计方法，清晰的流程图，是实现这一目标的重要保证。</p>
+<ol start="4">
+<li>整体项目评估能力</li>
+</ol>
+<p>作为系统设计人员，必须能够从全局出发，对项目又整体的清醒认识，比如公司的资源配置是否合理和到位，比如工程进度安排是否能最大化体现效率又不至于无法按期完成。评估项 目整体和各个模块的工作量，评估项目所需的资源，评估项目可能遇到的困难，都需要大量的经验积累，换言之，这是一种不断总结的累计才能达到的境界。在西方一些软件系统设计的带头人都是很年长的，比如4，50岁，甚至更老，他们在编码方面已经远远不如年轻人那样活络，但是就项目评估而言，他们几十年的经验积累就是最重要和宝贵的财富。中国缺这么一代程序员，主要还不是缺那种年纪的程序员，而是那种年纪的程序员基本上都是研究单位作出来的，都不是从专业的产品化软件研发作出来的，他们没有能积累那种产品化研发的经验，这也是没有办法的事情。</p>
+<ol start="5">
+<li>团队组织管理能力</li>
+</ol>
+<p>完成一个项目工程，需要团队的齐心协力，作为项目设计者或研发的主管人，就应当有能力最大化发挥团队的整体力量，技术管理由于其专业性质，不大同于一般的人事管理，因为这里面设计了一些技术性的指标和因素。</p>
+<p>首先是工作的量化，没有量化就很难做到合适的绩效考核，而程序量化又不是简单的代码行数可以计算的，因此要求技术管理人员需要能真正评估一个模块的复杂性和工作量。</p>
+<p>其次是对团队协作模式的调整，一般而言，程序开发的协作通常分为小组进行，小组有主程序员方式的，也有民主方式的，根据程序员之间的能力水平差距，以及根据项目研发的需求，选择合适的组队方式，并能将责权和成员的工作任务紧密结合，这样才能最大发挥组队的效率。</p>
+<p>一个代码水平高的人，未必能成为一个合格的项目研发主管，这方面的能力欠缺往往是容易被忽视的。</p>
+<p>综上可以看到，作为一个主管研发的负责人，一个项目设计者，所需要具备的素质和能力并不是程序代码编写的能力，当然一般情况下，一个程序员通过不断的总结提高达到了这种素质的时候，他所具有的代码编写能力也已经相当不简单了，但是请注意这里面的因果关系，一个高水平的项目设计者通常已经是代码编写相当优秀的人了，但是并不是一个代码相当优秀的程序员就可以胜任项目设计的工作，这里面存在的也不是智商和课本的问题，还是在于一个程序员在积累经验，逐步提升的时候没有意识到应当思考哪方面的东西，没有有意识的就项目的组织和复用设计进行揣摩，没有经常性的文档习惯和总结习惯， 不改变这些，我们的合格的项目设计者还是非常欠缺。</p>
+<p>另外，为防止有无聊的人和我较真，补充一点，本文针对目标是作商业化的软件项目和工程，那些科研机构的编程高手，比如算法高手，比如图象处理高手，他们的工作是研究课题而非直接完成商业软件（当然最终间接成为商业产品，比如微软研究院在作的研究课题），因此他们强调的素质可能是另外的东西，这些人（专家），并不能说是程序员，不能用程序员的标准去衡量。</p>
+<p>最后补充一点东西，一个软件项目研发的设计流程是怎样的呢？以通常标准的设计方法为例，（不过笔者喜欢快速原型法）。</p>
+<ul>
+<li>
+<p>第一个步骤是市场调研，技术和市场要结合才能体现最大价值。</p>
+</li>
+<li>
+<p>第二个步骤是需求分析，这个阶段需要出三样东西，用户视图，数据词典和用户操作手册。用户视图是该软件用户（包括终端用户和管理用户）所能看到的页面样式，这里面包含了很多操作方面的流程和条件。数据词典是指明数据逻辑关系并加以整理的东东，完成了数据词典，数据库的设计就完成了一半多。用户操作手册是指明了操作流程的说明书。</p>
+</li>
+</ul>
+<p>注意，用户操作流程和用户视图是由需求决定的，因此应该在软件设计之前完成，完成这些，就为程序研发提供了约束和准绳，很遗憾太多公司都不是这样做的，因果颠倒，顺序不分，开发工作和实际需求往往因此 产生隔阂脱节的现象。</p>
+<p>需求分析，除了以上工作，笔者以为作为项目设计者应当完整的做出项目的性能需求说明书，因为往往性能需求只有懂技术的人才可能理解，这就需要技术专家和需求方（客户或公司市场部门）能够有真正的沟通和了解。</p>
+<ul>
+<li>
+<p>第三个步骤是概要设计，将系统功能模块初步划分，并给出合理的研发流程和资源要求。作为快速原型设计方法，完成概要设计就可以进入编码阶段了，通常采用这种方法是因为涉及的研发任务属于新领域，技术主管人员一上来无法给出明确的详细设计说明书，但是并不是说详细设计说明书不重要，事实上快速原型法在完成原型代码后，根据评测结果和经验教训的总结，还要重新进行详细设计的步骤。</p>
+</li>
+<li>
+<p>第四个步骤是详细设计，这是考验技术专家设计思维的重 要关卡，详细设计说明书应当把具体的模块以最‘干净’的方式(黑箱结构）提供给编码者，使得系统整体模块化达到最大；一份好的详细设计说明书，可以使编码的复杂性减低到最低，实际上，严格的讲详细设计说明书应当把每个函数的每个参数的定义都精精细细的提供出来，从需求分析到概要设计到完成详细设计说明书，一个软件项目就应当说完成了一半了。换言之，一个大型软件系统在完成了一半的时候，其实还没有开始一行代码工作。那些把作软件的程序员简单理解为写代码的，就从根子上犯了错误了。</p>
+</li>
+<li>
+<p>第五个步骤是编码，在规范化的研发流程中，编码工作在整个项目流程里最多不会超过1/2，通常在1/3的时间，所谓磨刀不误砍柴功，设计过程完成的好，编码效率就会极大提高，编码时不同模块之间的进度协调和协作是最需要小心的，也许一个小模块的问题就可能影响了整体进度，让很多程序员因此被迫停下工作等待，这种问题在很多研发过程中都出现过。编码时的相互沟通和应急的解决手段都是相当重要的，对于程序员而言，bug永远存在，你必须永远面对这个问题，大名鼎鼎的微软，可曾有连续三个月不发补丁的时候吗？从来没有！</p>
+</li>
+<li>
+<p>第六个步骤是测试</p>
+</li>
+</ul>
+<p>测试有很多种：按照测试执行方，可以分为内部测试和外部测试；按照测试范围，可以分为模块测试和整体联调；按照测试条 件，可以分为正常操作情况测试和异常情况测试；按照测试的输入范围，可以分为全覆盖测试和抽样测试。以上都很好理解，不再解释。</p>
+<p>总之，测试同样是项目研发中一个相当重要的步骤，对于一个大型软件，3个月到1年的外部测试都是正常的，因为永远都会又不可预料的问题存在。</p>
+<p>完成测试后，完成验收并完成最后的一些帮助文档，整体项目才算告一段落，当然日后少不了升级，修补等等工作，只要不是想通过一锤子买卖骗钱，就要不停的跟踪软件的运营状况并持续修补升级，知道这个软件被彻底淘汰为止。</p>
+<p>写这些步骤算不上卖弄什么，因为实话讲我手边是一本《软件工程》，在大学里这是计算机专业的必修课程，但是我知道很多程序员似乎从来都只是热衷于什么《30天精通VC》之类的，他们有些和我一样游击队出身，没有正规学过这个专业，还有一些则早就在混够学分后就把这些真正有用的东西还给了老师。</p>
+<p>fans乱嚷嚷，混淆视听，实际上真正的技术专家很少在网上乱发帖子的，如笔者这样不知天高地厚的，其实实在是算不上什么高手，只不过看不惯这种对技术，对程序员的误解和胡说，只好挺身而出，做拨乱反正之言，也希望那些还fans们能认真想想，走到正途上，毕竟那些聪明的头脑还远远没有发挥应有的价值。沉迷于一些错误人士的coding</p>
+<p>从程序员升级到工程师大多数象我这样对软件有浓厚兴趣的人，毕业后义无反顾地走进了企业，开始了程序员的生涯。那时，我们迷恋“大全”、“秘籍”一类的书籍，心中只有代码。当我看到一行行枯燥的代码变成了能够打电话的设备，变成了屏幕上漂亮的表格，变成了动听的音乐，成就感油然而生。我觉得自己也是一个出色的程序员了。在用户的机房中苦熬三昼夜解决软件的bug，也成了一种可以夸耀的资历。五年前的某一天，我把曾经让我兴奋自豪的大量代码和少得可怜的文档移交之后，来到了华为。这里有更多的年轻人，我如鱼得水，可以充分发挥自己的想象力。依然是代码，依然是匆匆地在纸上记下稍纵即逝的灵感（我们把它称作文档），依然是无休止地和bug作斗争。当有一天，一个新来 的同事拿着署着我的大名的文档，小心翼翼地来问我时，我发现自己好象有点不认识它了。我心里有点沮丧，再看看代码，发现文档上记录的一些灵感已面目全非。我当时不知道那位新来的同事感受如何，但我从那时起，好象意识到什么。现在来看，那时的很多事情都是事倍功半。</p>
+<p>去年年底，我学习印度从事项目开发，学习印度的软件开发管理方法。一种久违的冲动在心底升起。我在学习过程中和印度的工程师交流过，他们言谈中透着自信。他们给我讲解正在做的软件的测试环境，给我看他们写的单元测试文档。当我看到一个软件模块的单元测试用例有三百多页时，我觉得心里很是沉重。当我第三次踏上这片土地时，我又见到了熟悉的人们，明亮的眼睛，温和的笑容，随意的穿着，风驰电掣的摩托，还有大学校园中穿着拖鞋，手抱书本的年轻人。</p>
+<p>我也见到了我的项目经理，一个个子较高，瘦瘦的年轻人，据说刚从美国回来，已工作了五、六年。我听了心里很高兴，这回要一招一式地学两手。需求分析的时间是一个月，项目经理和我们（实际上代表客户 ）讨论了proposal中的内容，确定每一项都是需要的。然后他把模块大致划分了一下，开始进入计划中的学习阶段。每个人在学习阶段要写出功能描述的胶片，给其他人讲解，不知不觉中，项目组的所有人对项目有了整体的了解。</p>
+<p>他还安排了一些培训，如他们公司的软件开发模型、项目组中各角色的定义，以后及时的培训不断，只要项目组中有需求，他总是把qa或相关的人请来，培训很专业。需求分析完成后提交了一份四十多页的文档，当我看到这份英文文档中我写的部分整整齐齐地列在其中时，我的感觉很复杂，有些喜悦，但更多的是苦涩，我以前怎么就从来没有这样做过需求分析呢。</p>
+<p>在我写文档的过程中，qa给我们培训过srs的写作模板，后来我还是不放心，让他们一个有经验的工程师写了一段，我们再琢磨着照着写。这份srs虽然是多个人合写，但风格一致，内容详实。更为可贵的是，一直到最后，这份需求分析的内容都没有改过，以至于我们没有机会走一下他们的需求更改流程。</p>
+<p>需求分析是项目的第一阶段，第二阶段的开发时间要根据需求分析的结果来确定。当对方的首席技术官（相当于我们业务部的总体组长）来和我们讨论计划时，他们已列出了对每个 模块的代码行数的预测，可能存在的风险。根据他们公司的生产率－－300行/人月，他得出了项目第二阶段需要多少周。</p>
+<p>我们当时就提出了异议：1）公司对该项目需求很急；2）每月300行是否太少；3）我们还有下载的源代码参考。他解释说，300行/人月是使得项目能达到他们质量标准的经验数据，考虑到有源代码参考，生产率最多不能超过350行/人月。</p>
+<p>当他问我们公司的生产率时，我脑袋里转了三个圈，没敢多说，大概六、七百行吧。他沉默了一会儿，然后坚定地说，我们这个计划是建立在确保质量的基础上的，我想你们到印度来开发软件，首先看中的应该是我们印度公司的质量保证。我知道你们不缺乏软件开发人员，你们为什么不选择下载的软件呢。几句话说到了我的痛处，现在国内的弟兄们还在为使用下载软件移植的产品四处奔波呢！</p>
+<p>随后的开发活动有条不紊，我们老老实实地跟着做。系统测试计划、用例，概要设计，集成测试计划、用例，详细设计，单元测试计划、用例，编码，单元测试，集成测试，系统测试。一个完整的v模型开发过程，其中每个过程都有review。当我们对一些设计的方法不太明白时，项目经理给我们发来了相关的资料，我不知道他当时是怎么想的，一些基本的分析、设计方法是十年，甚至二十年前的软件工程书中就讲到的，印度每个计算机专业的人员都是必修这些内容的。而我们除了对一些具体协议的代码很熟之外，对这些常用的方法似乎一无所知。我感到一些羞愧，进城直奔书店，把他给我开列的书找了出来，晚上躺在床上，仔细研读，我仿佛突然又遇到了能给我指点迷津的良师益友。现在印度所已形成了强烈的学习风气。我回来后也推销了700多本书，这些书教我们如何用工程化的方法开发软件，是成为一个软件工程师必读的资料。</p>
+<p>我们的项目经理的计划控制能力很强，当有什么影响到项目计划的事情发生时，如人员辞职、实验室搬家、某一模块预测不准（该模块是我们预测的），他总是采取必要的措施，减少延期，调整计划。刚开始，我们对他们每天上午11点，下午4点下楼喝咖啡还有点意见，后来也跟着喝去了，原来，喝咖啡时的交流非常丰富，从项目管理到设计方法，从技术发展到风土人情，无所不包，对我们互相之间的理解，对团队的气氛很有帮助。我们项目的qa也在适当的时候出现在我们的面前，我们对她的工作只有一些感性认识。她每次参加会议时，手里时常拿着一个check list，项目经理准备相应的资料，回答一些问题，她打着勾，或写着项目经理的解释。她给我们做培训时也很耐心，体现出很好的职业素养，我至今还在怀念她给我们的帮助。</p>
+<p>我从事软件开发已有四个年头了，可我现在仍然不能说自己是个合格的软件工程师，更不用谈什么合格的管理者。我看到一份报道说，瑞士洛桑一权威机构把中国的科技综合竞争力从原来的第十三位调到二十多位，原因是他们调整了一些评估标准，其中有一条是中国合格工程师的可获得性非常低。想着弟兄们熬红的双眼，四处奔波升级的疲惫身影，我有一个强烈的愿望：快把我们自己升级成合格的工程师吧!</p>
+</section><footer class="footer-container"><div class="footer-body"><img src="/img/dubbo_gray.png"/><div class="cols-container"><div class="col col-12"><h3>免责声明</h3><p>免责声明的具体内容</p></div><div class="col col-6"><dl><dt>文档</dt><dd><a href="/zh-cn/docs/introduction.html" target="_self">概览</a></dd><dd><a href="/zh-cn/docs/introduction.html" target="_self">快速开始</a></dd><dd><a href="/zh-cn/docs/dir/introduction.html" target="_self">开发者指南</a></dd></dl></div><div class="col col-6"><dl><dt>资源</dt><dd><a href="/zh-cn/blog/index.html" target="_self">博客</a></dd><dd><a href="/zh-cn/community/index.html" target="_self">社区</a></dd></dl></div></div><div class="copyright"><span>Copyright © 2018 BurningMyself</span></div></div></footer></div></div>
+	<script src="https://f.alicdn.com/react/15.4.1/react-with-addons.min.js"></script>
+	<script src="https://f.alicdn.com/react/15.4.1/react-dom.min.js"></script>
+	<script>
+		window.rootPath = '';
+  </script>
+	<script src="/build/blogDetail.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/zh-cn/blog/framework/fwork.json b/zh-cn/blog/framework/fwork.json
new file mode 100644
index 0000000..bc83f74
--- /dev/null
+++ b/zh-cn/blog/framework/fwork.json
@@ -0,0 +1,6 @@
+{
+  "filename": "fwork.md",
+  "__html": "<h1>走向架构师必备的技能</h1>\n<p>中国有很多年轻人，他们18,9岁或21,2岁，通过自学也写了不少代码，他们有的代码写的很漂亮，一些技术细节相当出众，也很有钻研精神，但是他们被一些错误的认识和观点左右，缺乏对系统，对程序的整体理解能力，这些人，一个网上的朋友说得很好，他们实际fans，压根没有资格称为程序员，但是据我所知，不少小网络公司的Cfans,拿着吓人的工资，做着吓人的项目，项目的结局通常也很吓人。</p>\n<h2>程序员基本素质：</h2>\n<p>作一个真正合格的程序员，或者说就是可以真正合格完成一些代码工作的程序员，应该具有的素质。</p>\n<ol>\n<li>团队精神和协作能力</li>\n</ol>\n<p>把它作为基本素质，并不是不重要，恰恰相反，这是程序员应该具备的最基本的，也是最重要的安身立命之本。把高水平程序员说成独行侠的都是在呓语，任何个人的力量都是有限的，即便如linus这样的天才，也需要通过组成强大的团队来创造奇迹，那些遍布全球的为linux写核心的高手们，没有协作精神是不可想象的。独行侠可以作一些赚钱的小软件发点小财，但是一旦进入一些大系统的研发团队，进入商业化和产品化的开发任务，缺乏这种素质的人就完全不合格了。</p>\n<ol start=\"2\">\n<li>文档习惯</li>\n</ol>\n<p>说高水平程序员从来不写文档的肯定是乳臭未干的毛孩子，良好的文档是正规研发流程中非常重要的环节，作为代码程序员，30％的工作时间写技术文档是很正常的，而作为高级程序员和系统分析员，这个比例还要高很多。缺乏文档，一个软件系统就缺乏生命力，在未来的查错，升级以及模块的复用时就都会遇到极大的麻烦。</p>\n<ol start=\"3\">\n<li>规范化，标准化的代码编写习惯</li>\n</ol>\n<p>作为一些外国知名软件公司的规矩，代码的变量命名，代码内注释格式，甚至嵌套中行缩进的长度和函数间的空行数字都有明确规定，良好的编写习惯，不但有助于代码的移植和纠错，也有助于不同技术人员之间的协作。\nfans叫嚣高水平程序员写的代码旁人从来看不懂，这种叫嚣只能证明他们自己压根不配自称程序员。代码具有良好的可读性，是程序员基本的素质需求。\n再看看整个linux的搭建，没有规范化和标准化的代码习惯，全球的研发协作是绝对不可想象的。</p>\n<ol start=\"4\">\n<li>需求理解能力</li>\n</ol>\n<p>程序员需要理解一个模块的需求，很多小朋友写程序往往只关注一个功能需求，他们把性能指标全部归结到硬件，操作系统和开发环境上，而忽视了本身代码的性能考虑，有人曾经放言说写一个广 告交换程序很简单，这种人从来不知道在百万甚至千万数量级的访问情况下的性能指标是如何实现的，对于这样的程序员，你给他深蓝那套系统，他也做不出太极链的并访能力。性能需求指标中，稳定性，并访支撑能力以及安全性都很重要，作为程序员需要评估该模块在系统运营中所处的环境，将要受到的负荷压力以及各种潜在的危险和恶意攻击的可能性。就这一点，一个成熟的程序员至少需要2到3年的项目研发和跟踪经验才有可能有心得。</p>\n<ol start=\"5\">\n<li>复用性，模块化思维能力</li>\n</ol>\n<p>经常可以听到一些程序员有这样的抱怨，写了几年程序，变成了熟练工，每天都是重复写一些没有任何新意的代码，这其实是中国软件人才最大浪费的地方，一些重复性工作变成了熟练程序员的主要工作，而这些，其实是完全可以避免的。</p>\n<p>复用性设计，模块化思维就是要程序员在完成任何一个功能模块或函数的时候，要多想一些，不要局限在完成当前任务的简单思路上，想想看该模块是否可以脱离这个系统存在，是否可以通过简单的修改参数的方式在其他系统和应用环境下直接引用，这样就能极大避免重复性的开发工作，如果一个软件研发单位和工作组能够在每一次研发过程中都考虑到这些问题，那么程序员就不会在重复性的工作中耽误太多时间，就会有更多时间和精力投入到创新的代码工作中去。</p>\n<p>一些好的程序模块代码，即便是70年代写成的，拿到现在放到一些系统里面作为功能模块都能适合的很好，而现在我看到的是，很多小公司软件一升级或改进就动辄全部代码重写，大部分重复性工作无谓的浪费了时间和精力。</p>\n<ol start=\"6\">\n<li>测试习惯</li>\n</ol>\n<p>作为一些商业化正规化的开发而言，专职的测试工程师是不可少的，但是并不是说有了专职的测试工程师程序员就可以不进行自测；软件研发作为一项工程而言，一个很重要的特点就是问题发现的越早，解决的代价就越低，程序员在每段代码，每个子模块完成后进行认真的测试，就可以尽量将一些潜在的问题最早的发现和解决，这样对整体系统建设的效率和可靠性就有了最大的保证。</p>\n<p>测试工作实际上需要考虑两方面，一方面是正常调用的测试，也就是看程序是否能在正常调用下完成基本功能，这是最基本的测试职责，可惜在很多公司这成了唯一的测试任务，实际上还差的远那；第二方面就是异常调用的测试，比如高压力负荷下的稳定性测试，用户潜在的异常输入情况下的测试，整体系统局部故障情况下该模块受影响状况的测试，频发的异常请求阻塞资源时的模块稳定测试等等。当然并不是程序员要对自己的每段代码都需要进行这种完整测试，但是程序员必须清醒认识自己的代码任务在整体项目中的地位和各种性能需求，有针对性的进行相关测试并尽早发现和解决问题，当然这需要上面提到需求理解能力。</p>\n<ol start=\"7\">\n<li>学习和总结的能力</li>\n</ol>\n<p>程序员是人才很容易被淘汰，很容易落伍的职业，因为一种技术可能仅仅在三两年内具有领先性，程序员如果想安身立命，就必须不断跟进新的技术，学习新的技能。</p>\n<p>善于学习，对于任何职业而言，都是前进所必需的动力，对于程序员，这种要求就更加高了。但是学习也要找对目标，一些小coding有些codingTO就是这样的coding上只是一些Cfans们，他们也津津乐道于他们的学习能力，一会学会了asp，一会儿学会了php，一会儿学会了jsp，他们把这个作为炫耀的资本，盲目的追逐一些肤浅的，表面的东西和名词，做网络程序不懂通讯传输协议，做应用程序不懂中断向量处理，这样的技术人员，不管掌握了多少所谓的新语言，永远不会有质的提高。</p>\n<p>善于总结，也是学习能力的一种体现，每次完 成一个研发任务，完成一段代码，都应当有目的的跟踪该程序的应用状况和用户反馈，随时总结，找到自己的不足，这样逐步提高，一个程序员才可能成长起来。</p>\n<p>一个不具备成长性的程序员，即便眼前看是个高手，建议也不要选用，因为他落伍的时候马上就到了。具备以上全部素质的人，应当说是够格的程序员了，请注意以上的各种素质都不是由IQ决定的，也不是大学某些课本里可以学习到的，需要的仅仅是程序员对自己工作的认识，是一种意识上的问题。</p>\n<h2>高级程序员</h2>\n<p>那么作为高级程序员，以至于系统分析员，也就是对于一个程序项目的设计者而言，除了应该具备上述全部素质之外，还需要具备以下素质：</p>\n<ol>\n<li>需求分析能力</li>\n</ol>\n<p>对于程序员而言，理解需求就可以完成合格的代码，但是对于研发项目的组织和管理者，他们不但要理解客户需求，更多时候还要自行制定一些需求，为什么这么说呢？</p>\n<p>一般而言，进行研发任务，也许是客户提出需求，也许是市场和营销部门提出的需求，这时候对于研发部门，他们看到的不是一个完整的需求，通常而言，该需求仅仅是一些功能上的要求，或者更正规些，可能获得一个完整的用户视图；但是这都不够，因为客户由于非技术因素多一些，他们可能很难提出完整和清晰，或者说专业性的性能需求，但是对于项目组织者和规划者，他必须能够清醒认识到这些需求的存在并在完成 需求分析报告的时候适当的提出，同时要完整和清晰的体现在设计说明书里面，以便于程序员编码时不会失去这些准则。</p>\n<p>程序设计者必须正确理解用户需求所处的环境，并针对性做出需求的分析，举例而言，同样一个软件通过ASP租用方式发布和通过License方式发布，性能需求可能就是有区别的，前者强调的是更好的支撑能力和稳定性，而后者则可能更强调在各种平台下的普适性和安装使用的简捷性。</p>\n<ol start=\"2\">\n<li>项目设计方法和流程处理能力</li>\n</ol>\n<p>程序设计者必须能够掌握不少于两到三种的项目设计方法（比如自顶至下的设计方法，比如快速原型法等等），并能够根据项目需求和资源搭配来选择合适的设计方法进行项 目的整体设计。设计方法上选择不当，就会耽误研发周期，浪费研发资源，甚至影响研发效果。</p>\n<p>一个程序设计者还需要把很多功夫用在流程图的设计和处理上，他需要做数据流图以确立数据词典；他需要加工逻辑流图以形成整体的系统处理流程。一个流程有问题的系统，就算代码多漂亮，每个模块多精致，也不会成为一个好的系统。当然，做好流程分析并选择好项目设计方法，都需要在需求分析能力上具有足够的把握。</p>\n<ol start=\"3\">\n<li>复用设计和模块化分解能力</li>\n</ol>\n<p>这个似乎又是老调重谈，前面基本素质上不是已经说明了这个问题吗？作为一个从事模块任务的程序员，他需要对他所面对的特定功能模块的 复用性进行考虑，而作为一个系统分析人员，他要面对的问题复杂的多，需要对整体系统按照一种模块化的分析能力分解为很多可复用的功能模块和函数，并针对每一模块形成一个独立的设计需求。举个例子，好比是汽车生产，最早每辆汽车都是独立安装的，每个部件都是量身定做的，但是后来不一样了，机器化大生产了，一个汽车厂开始通过流水线来生产汽车，独立部件开始具有一定的复用性，在后来标准化成为大趋势，不同型号，品牌甚至不同厂商的汽车部件也可以进行方便的换装和升级，这时候，汽车生产的效率达到最大化。软件工程也是同样的道理，一个成熟的软件行业，在一些相关项目和系统中，不同的部件是可以随意换装的，比如微软的许多桌面软件，在很多操作模块（如打开文件，保存文件等等）都是复用的同一套功能模块，而这些接口又通过一些类库提供给了桌面应用程序开发者方便挂接，这就是复用化的模块设计明显的一个佐证。</p>\n<p>将一个大型的，错综复杂的应用系统分解成一些相对独立的，具有高度复用性的，并能仅仅依靠几个参数完成数据联系的模块组合，是作为高级程序员和系统分析员一项最重要的工作，合适的项目设计方法，清晰的流程图，是实现这一目标的重要保证。</p>\n<ol start=\"4\">\n<li>整体项目评估能力</li>\n</ol>\n<p>作为系统设计人员，必须能够从全局出发，对项目又整体的清醒认识，比如公司的资源配置是否合理和到位，比如工程进度安排是否能最大化体现效率又不至于无法按期完成。评估项 目整体和各个模块的工作量，评估项目所需的资源，评估项目可能遇到的困难，都需要大量的经验积累，换言之，这是一种不断总结的累计才能达到的境界。在西方一些软件系统设计的带头人都是很年长的，比如4，50岁，甚至更老，他们在编码方面已经远远不如年轻人那样活络，但是就项目评估而言，他们几十年的经验积累就是最重要和宝贵的财富。中国缺这么一代程序员，主要还不是缺那种年纪的程序员，而是那种年纪的程序员基本上都是研究单位作出来的，都不是从专业的产品化软件研发作出来的，他们没有能积累那种产品化研发的经验，这也是没有办法的事情。</p>\n<ol start=\"5\">\n<li>团队组织管理能力</li>\n</ol>\n<p>完成一个项目工程，需要团队的齐心协力，作为项目设计者或研发的主管人，就应当有能力最大化发挥团队的整体力量，技术管理由于其专业性质，不大同于一般的人事管理，因为这里面设计了一些技术性的指标和因素。</p>\n<p>首先是工作的量化，没有量化就很难做到合适的绩效考核，而程序量化又不是简单的代码行数可以计算的，因此要求技术管理人员需要能真正评估一个模块的复杂性和工作量。</p>\n<p>其次是对团队协作模式的调整，一般而言，程序开发的协作通常分为小组进行，小组有主程序员方式的，也有民主方式的，根据程序员之间的能力水平差距，以及根据项目研发的需求，选择合适的组队方式，并能将责权和成员的工作任务紧密结合，这样才能最大发挥组队的效率。</p>\n<p>一个代码水平高的人，未必能成为一个合格的项目研发主管，这方面的能力欠缺往往是容易被忽视的。</p>\n<p>综上可以看到，作为一个主管研发的负责人，一个项目设计者，所需要具备的素质和能力并不是程序代码编写的能力，当然一般情况下，一个程序员通过不断的总结提高达到了这种素质的时候，他所具有的代码编写能力也已经相当不简单了，但是请注意这里面的因果关系，一个高水平的项目设计者通常已经是代码编写相当优秀的人了，但是并不是一个代码相当优秀的程序员就可以胜任项目设计的工作，这里面存在的也不是智商和课本的问题，还是在于一个程序员在积累经验，逐步提升的时候没有意识到应当思考哪方面的东西，没有有意识的就项目的组织和复用设计进行揣摩，没有经常性的文档习惯和总结习惯， 不改变这些，我们的合格的项目设计者还是非常欠缺。</p>\n<p>另外，为防止有无聊的人和我较真，补充一点，本文针对目标是作商业化的软件项目和工程，那些科研机构的编程高手，比如算法高手，比如图象处理高手，他们的工作是研究课题而非直接完成商业软件（当然最终间接成为商业产品，比如微软研究院在作的研究课题），因此他们强调的素质可能是另外的东西，这些人（专家），并不能说是程序员，不能用程序员的标准去衡量。</p>\n<p>最后补充一点东西，一个软件项目研发的设计流程是怎样的呢？以通常标准的设计方法为例，（不过笔者喜欢快速原型法）。</p>\n<ul>\n<li>\n<p>第一个步骤是市场调研，技术和市场要结合才能体现最大价值。</p>\n</li>\n<li>\n<p>第二个步骤是需求分析，这个阶段需要出三样东西，用户视图，数据词典和用户操作手册。用户视图是该软件用户（包括终端用户和管理用户）所能看到的页面样式，这里面包含了很多操作方面的流程和条件。数据词典是指明数据逻辑关系并加以整理的东东，完成了数据词典，数据库的设计就完成了一半多。用户操作手册是指明了操作流程的说明书。</p>\n</li>\n</ul>\n<p>注意，用户操作流程和用户视图是由需求决定的，因此应该在软件设计之前完成，完成这些，就为程序研发提供了约束和准绳，很遗憾太多公司都不是这样做的，因果颠倒，顺序不分，开发工作和实际需求往往因此 产生隔阂脱节的现象。</p>\n<p>需求分析，除了以上工作，笔者以为作为项目设计者应当完整的做出项目的性能需求说明书，因为往往性能需求只有懂技术的人才可能理解，这就需要技术专家和需求方（客户或公司市场部门）能够有真正的沟通和了解。</p>\n<ul>\n<li>\n<p>第三个步骤是概要设计，将系统功能模块初步划分，并给出合理的研发流程和资源要求。作为快速原型设计方法，完成概要设计就可以进入编码阶段了，通常采用这种方法是因为涉及的研发任务属于新领域，技术主管人员一上来无法给出明确的详细设计说明书，但是并不是说详细设计说明书不重要，事实上快速原型法在完成原型代码后，根据评测结果和经验教训的总结，还要重新进行详细设计的步骤。</p>\n</li>\n<li>\n<p>第四个步骤是详细设计，这是考验技术专家设计思维的重 要关卡，详细设计说明书应当把具体的模块以最‘干净’的方式(黑箱结构）提供给编码者，使得系统整体模块化达到最大；一份好的详细设计说明书，可以使编码的复杂性减低到最低，实际上，严格的讲详细设计说明书应当把每个函数的每个参数的定义都精精细细的提供出来，从需求分析到概要设计到完成详细设计说明书，一个软件项目就应当说完成了一半了。换言之，一个大型软件系统在完成了一半的时候，其实还没有开始一行代码工作。那些把作软件的程序员简单理解为写代码的，就从根子上犯了错误了。</p>\n</li>\n<li>\n<p>第五个步骤是编码，在规范化的研发流程中，编码工作在整个项目流程里最多不会超过1/2，通常在1/3的时间，所谓磨刀不误砍柴功，设计过程完成的好，编码效率就会极大提高，编码时不同模块之间的进度协调和协作是最需要小心的，也许一个小模块的问题就可能影响了整体进度，让很多程序员因此被迫停下工作等待，这种问题在很多研发过程中都出现过。编码时的相互沟通和应急的解决手段都是相当重要的，对于程序员而言，bug永远存在，你必须永远面对这个问题，大名鼎鼎的微软，可曾有连续三个月不发补丁的时候吗？从来没有！</p>\n</li>\n<li>\n<p>第六个步骤是测试</p>\n</li>\n</ul>\n<p>测试有很多种：按照测试执行方，可以分为内部测试和外部测试；按照测试范围，可以分为模块测试和整体联调；按照测试条 件，可以分为正常操作情况测试和异常情况测试；按照测试的输入范围，可以分为全覆盖测试和抽样测试。以上都很好理解，不再解释。</p>\n<p>总之，测试同样是项目研发中一个相当重要的步骤，对于一个大型软件，3个月到1年的外部测试都是正常的，因为永远都会又不可预料的问题存在。</p>\n<p>完成测试后，完成验收并完成最后的一些帮助文档，整体项目才算告一段落，当然日后少不了升级，修补等等工作，只要不是想通过一锤子买卖骗钱，就要不停的跟踪软件的运营状况并持续修补升级，知道这个软件被彻底淘汰为止。</p>\n<p>写这些步骤算不上卖弄什么，因为实话讲我手边是一本《软件工程》，在大学里这是计算机专业的必修课程，但是我知道很多程序员似乎从来都只是热衷于什么《30天精通VC》之类的，他们有些和我一样游击队出身，没有正规学过这个专业，还有一些则早就在混够学分后就把这些真正有用的东西还给了老师。</p>\n<p>fans乱嚷嚷，混淆视听，实际上真正的技术专家很少在网上乱发帖子的，如笔者这样不知天高地厚的，其实实在是算不上什么高手，只不过看不惯这种对技术，对程序员的误解和胡说，只好挺身而出，做拨乱反正之言，也希望那些还fans们能认真想想，走到正途上，毕竟那些聪明的头脑还远远没有发挥应有的价值。沉迷于一些错误人士的coding</p>\n<p>从程序员升级到工程师大多数象我这样对软件有浓厚兴趣的人，毕业后义无反顾地走进了企业，开始了程序员的生涯。那时，我们迷恋“大全”、“秘籍”一类的书籍，心中只有代码。当我看到一行行枯燥的代码变成了能够打电话的设备，变成了屏幕上漂亮的表格，变成了动听的音乐，成就感油然而生。我觉得自己也是一个出色的程序员了。在用户的机房中苦熬三昼夜解决软件的bug，也成了一种可以夸耀的资历。五年前的某一天，我把曾经让我兴奋自豪的大量代码和少得可怜的文档移交之后，来到了华为。这里有更多的年轻人，我如鱼得水，可以充分发挥自己的想象力。依然是代码，依然是匆匆地在纸上记下稍纵即逝的灵感（我们把它称作文档），依然是无休止地和bug作斗争。当有一天，一个新来 的同事拿着署着我的大名的文档，小心翼翼地来问我时，我发现自己好象有点不认识它了。我心里有点沮丧，再看看代码，发现文档上记录的一些灵感已面目全非。我当时不知道那位新来的同事感受如何，但我从那时起，好象意识到什么。现在来看，那时的很多事情都是事倍功半。</p>\n<p>去年年底，我学习印度从事项目开发，学习印度的软件开发管理方法。一种久违的冲动在心底升起。我在学习过程中和印度的工程师交流过，他们言谈中透着自信。他们给我讲解正在做的软件的测试环境，给我看他们写的单元测试文档。当我看到一个软件模块的单元测试用例有三百多页时，我觉得心里很是沉重。当我第三次踏上这片土地时，我又见到了熟悉的人们，明亮的眼睛，温和的笑容，随意的穿着，风驰电掣的摩托，还有大学校园中穿着拖鞋，手抱书本的年轻人。</p>\n<p>我也见到了我的项目经理，一个个子较高，瘦瘦的年轻人，据说刚从美国回来，已工作了五、六年。我听了心里很高兴，这回要一招一式地学两手。需求分析的时间是一个月，项目经理和我们（实际上代表客户 ）讨论了proposal中的内容，确定每一项都是需要的。然后他把模块大致划分了一下，开始进入计划中的学习阶段。每个人在学习阶段要写出功能描述的胶片，给其他人讲解，不知不觉中，项目组的所有人对项目有了整体的了解。</p>\n<p>他还安排了一些培训，如他们公司的软件开发模型、项目组中各角色的定义，以后及时的培训不断，只要项目组中有需求，他总是把qa或相关的人请来，培训很专业。需求分析完成后提交了一份四十多页的文档，当我看到这份英文文档中我写的部分整整齐齐地列在其中时，我的感觉很复杂，有些喜悦，但更多的是苦涩，我以前怎么就从来没有这样做过需求分析呢。</p>\n<p>在我写文档的过程中，qa给我们培训过srs的写作模板，后来我还是不放心，让他们一个有经验的工程师写了一段，我们再琢磨着照着写。这份srs虽然是多个人合写，但风格一致，内容详实。更为可贵的是，一直到最后，这份需求分析的内容都没有改过，以至于我们没有机会走一下他们的需求更改流程。</p>\n<p>需求分析是项目的第一阶段，第二阶段的开发时间要根据需求分析的结果来确定。当对方的首席技术官（相当于我们业务部的总体组长）来和我们讨论计划时，他们已列出了对每个 模块的代码行数的预测，可能存在的风险。根据他们公司的生产率－－300行/人月，他得出了项目第二阶段需要多少周。</p>\n<p>我们当时就提出了异议：1）公司对该项目需求很急；2）每月300行是否太少；3）我们还有下载的源代码参考。他解释说，300行/人月是使得项目能达到他们质量标准的经验数据，考虑到有源代码参考，生产率最多不能超过350行/人月。</p>\n<p>当他问我们公司的生产率时，我脑袋里转了三个圈，没敢多说，大概六、七百行吧。他沉默了一会儿，然后坚定地说，我们这个计划是建立在确保质量的基础上的，我想你们到印度来开发软件，首先看中的应该是我们印度公司的质量保证。我知道你们不缺乏软件开发人员，你们为什么不选择下载的软件呢。几句话说到了我的痛处，现在国内的弟兄们还在为使用下载软件移植的产品四处奔波呢！</p>\n<p>随后的开发活动有条不紊，我们老老实实地跟着做。系统测试计划、用例，概要设计，集成测试计划、用例，详细设计，单元测试计划、用例，编码，单元测试，集成测试，系统测试。一个完整的v模型开发过程，其中每个过程都有review。当我们对一些设计的方法不太明白时，项目经理给我们发来了相关的资料，我不知道他当时是怎么想的，一些基本的分析、设计方法是十年，甚至二十年前的软件工程书中就讲到的，印度每个计算机专业的人员都是必修这些内容的。而我们除了对一些具体协议的代码很熟之外，对这些常用的方法似乎一无所知。我感到一些羞愧，进城直奔书店，把他给我开列的书找了出来，晚上躺在床上，仔细研读，我仿佛突然又遇到了能给我指点迷津的良师益友。现在印度所已形成了强烈的学习风气。我回来后也推销了700多本书，这些书教我们如何用工程化的方法开发软件，是成为一个软件工程师必读的资料。</p>\n<p>我们的项目经理的计划控制能力很强，当有什么影响到项目计划的事情发生时，如人员辞职、实验室搬家、某一模块预测不准（该模块是我们预测的），他总是采取必要的措施，减少延期，调整计划。刚开始，我们对他们每天上午11点，下午4点下楼喝咖啡还有点意见，后来也跟着喝去了，原来，喝咖啡时的交流非常丰富，从项目管理到设计方法，从技术发展到风土人情，无所不包，对我们互相之间的理解，对团队的气氛很有帮助。我们项目的qa也在适当的时候出现在我们的面前，我们对她的工作只有一些感性认识。她每次参加会议时，手里时常拿着一个check list，项目经理准备相应的资料，回答一些问题，她打着勾，或写着项目经理的解释。她给我们做培训时也很耐心，体现出很好的职业素养，我至今还在怀念她给我们的帮助。</p>\n<p>我从事软件开发已有四个年头了，可我现在仍然不能说自己是个合格的软件工程师，更不用谈什么合格的管理者。我看到一份报道说，瑞士洛桑一权威机构把中国的科技综合竞争力从原来的第十三位调到二十多位，原因是他们调整了一些评估标准，其中有一条是中国合格工程师的可获得性非常低。想着弟兄们熬红的双眼，四处奔波升级的疲惫身影，我有一个强烈的愿望：快把我们自己升级成合格的工程师吧!</p>\n",
+  "link": "\\zh-cn\\blog\\framework\\fwork.html",
+  "meta": {}
+}
\ No newline at end of file