<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>ThoughtWorks on I Code It</title>
    <link>https://icodeit.org/categories/thoughtworks/</link>
    <description>Recent content in ThoughtWorks on I Code It</description>
    <generator>Hugo -- gohugo.io</generator>
    <lastBuildDate>Wed, 12 Dec 2018 00:00:00 +0000</lastBuildDate><atom:link href="https://icodeit.org/categories/thoughtworks/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>你要专业</title>
      <link>https://icodeit.org/2018/12/be-professional/</link>
      <pubDate>Wed, 12 Dec 2018 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2018/12/be-professional/</guid>
      <description>在我不算长的职业生涯中，有很多同事都给过我正面的评价（当然，可能有更多负面的评价，不过我都选择性的遗忘掉了）。有人欣赏我的命令行技巧，有人则称赞我代码写的比较快，有人说我的Vim的插件配置的很高效，还有人说坐在我旁边写PPT效率会变高。而我自己最喜欢一个评价是：有我在项目上的时候，团队就会觉得安心。</description>
      <content:encoded><![CDATA[<h1 id="你要专业">你要专业</h1>
<p>在我不算长的职业生涯中，有很多同事都给过我正面的评价（当然，可能有更多负面的评价，不过我都选择性的遗忘掉了）。有人欣赏我的命令行技巧，有人则称赞我代码写的比较快，有人说我的Vim的插件配置的很高效，还有人说坐在我旁边写PPT效率会变高。而我自己最喜欢一个评价是：有我在项目上的时候，团队就会觉得安心。</p>
<p>我喜欢这个评价是因为它是我希望自己能展现的一个状态：成为一个<strong>靠谱的职场人</strong>。关于靠谱的职场人，《重来》的作者之一<em>Jason</em>有一个很精炼的描述：</p>
<blockquote>
<p>Work ethic is about showing up, being on time, being reliable, doing what you say you’re going to do, being trustworthy, putting in a fair day’s work, respecting the work, respecting the customer, respecting the organization, respecting co-workers, not wasting time, not making work hard for other people, not creating unnecessary work for other people, not being a bottleneck, not faking work. Work ethic is about being a fundamentally good person that others can count on and enjoy working with. &ndash; Jason Fried</p>
</blockquote>
<p>歌词大意是：职业精神就是可靠，言出必行，尊重工作，不要浪费时间，不给别人添麻烦等等。不过，精炼的描述往往失之可操作性不够强。就好比知道“高内聚，低耦合”并不能帮助你写好代码一样。在这篇文章里，我打算举一些日常工作中常见的例子，尝试通过<code>Specification By Example</code>的方式给<strong>靠谱的职场人</strong>下一个定义。</p>
<p>在职场中，靠谱的意思就是：<strong>成为一个别人会信赖并乐于和你一起工作的人</strong>。而人们喜欢和靠谱的人一起工作。</p>
<h2 id="尊重你的工作">尊重你的工作</h2>
<p>人们站在不同的立场看待同一件事情时，必然会产生分歧。这几乎在项目中随处可以见，比如对于某个Feature，客户认为必须实现，这样在年终的绩效考核中才有令领导满意的成绩；另一方面，对于交付团队来说，技术上难以实现或者工作量太大，难以在有限的时间内完成；开发团队钟爱新的流行的技术栈，而客户则相对保守，需要考虑培训成本等等其他方面的因素。如果再加上沟通不畅，很容易导致团队士气低落，甚至双方互相抱怨。</p>
<p>一份工作，既是企业（企业中的员工）赖以生存的条件，又是企业和服务对象共同为社会创造价值的载体。这个产品可以解决某些人的问题，提高效率，为社会带来价值。工作本身就是值得尊重的。如果你被指派到一个项目上，并且作为个人，你不认为这个项目违背了自己的价值观，那就应该全力以赴去完成它。另一方面，如果你认为项目的价值和自己的三观不匹配（（比如，如果有人出钱让你去开发GFW之类的工具；或者一个工具用来监控员工的桌面等）），你完全可以选择不去参加这个项目。</p>
<p>新人常犯的一个错误是将<em>遵循既有规则</em>当成尊重。举个例子，在实际交付的时候，团队中的Tech Lead做出了一项你任务是错误的决策，作为团队成员，你可以据理力争，表达自己的看法，并提出自己的提议。另一方面，你也可以假装这个决策是超出你控制范围的，并且假装它是正确的，然后低头来按照决策来实施。在我看来，第二种看似尊重的行为是对团队和项目的非常的不尊重。退而言之，即使你的提议被拒掉，你也可以从中学到很多之前看不到的知识。一方面可以帮助你自己理清思路，看到自己方案的缺点，另一方面，你可以学习人们在实际项目中，如何对于不同的条件来做妥协。</p>
<h2 id="与他人合作">与他人合作</h2>
<blockquote>
<p>一个人可以走的更快，一群人可以走的更远 — 非洲谚语</p>
</blockquote>
<p>我们的日常工作中，总避免不了要和不同角色，不同经验的人一起工作。和单枪匹马独自作战不同的是，在一个群体中，个人的行为需要遵循一定的约定，需要和其他团队成员一起配合来完成任务。换句话说，要有团队合作精神。在和其他人一起工作时，第一要义是<em>不要为别人制造更多的工作量</em>。事实上，你应该在自己能力允许的前提下，尽可能让别人做最少的工作。相信我，你会希望自己和这样的人合作的。</p>
<p>我们从一个假象出来的场景出发，来看看如何在类似的场景中展现专业性：</p>
<h3 id="ci服务器地址">CI服务器地址</h3>
<p>设想这样一个场景：你所在的团队有一个微信群，大家很多问题都在群里提出并讨论。但是一些简单问题可能被频繁的问道，比如<strong>XXX服务器的地址是啥</strong>？前两天又有一个新人加入了团队，他今天在群里问了一个之前被回答过好几次的问题：<em>谁知道CI服务器的地址，请发给我一下，多谢！</em></p>
<p><img loading="lazy" src="/images/2018/12/ci.png" type="" alt=""  /></p>
<p>而这时候，你可以做什么呢？“我之前发过邮件给所有人了，你翻一下邮件”。</p>
<p>这是一个可行的方案，但是需要</p>
<ul>
<li>邮件标题的关键字 或者</li>
<li>邮件正文关键字</li>
</ul>
<p>而要做搜索本身动作，他需要打开邮件客户端或者在浏览器打开Web Mail，如果是访问Web Mail，他可能还要登录公司内网（输入密码），还可能要查看Okta推送的消息，这又需要打开手机，切换到Okta，点击确认。如果工作环境网络有vpn的隔离，情况可能会更复杂。</p>
<p>如果你花费1分钟帮他搜一下，然后把地址发给他，并告诉他用户名/密码就是域账号的用户名/密码，效果则会好很多。</p>
<h3 id="访问外部api">访问外部API</h3>
<p>如果我们把这个场景在稍微复杂化一点：有人在微信群问如何在<code>Postman</code>中访问获取所有网点信息的API。要访问这个API，客户端需要一个<code>Endpoint</code>和一些特定的<code>HTTP Header</code>。最简单的做法是发送一个截图。</p>
<p>不幸的是，Header中有一个叫做<code>x-api-token</code>，它的值是一个256个字符的hash。这时候图片就变得毫无用处了：你不会期望问问题的那个人用手敲一遍token吧？另一个方法是把API的Endpoint和所需的<code>HTTP Header</code>是分别以文本形式发送给他，（如果这个API需要多个header的话，你可能要复制粘贴好几次）。</p>
<p>再进一步，你可以通过一个<code>cURL</code>加命令行参数的方式将这些内容一次性发送给他:</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ curl -H <span class="s2">&#34;x-api-token: token&#34;</span> -H <span class="s2">&#34;Accept:application/json&#34;</span> https://host:port/top-security-resources/1
</code></pre></div><p>嗯，挺不错的。不过如果明天又有其他人问你要这个API的访问方式，你又要再来一遍，还是比较麻烦。你稍微翻了下<code>Postman</code>的帮助，发现它支持导出，还可以定义一些环境参数等。如果将这些内容都导出出来，然后放在代码仓库中，其他所有人就无需每次都找人要各种URL了。</p>
<p>显然，最后一种方法既满足当前的需求，又有很好的可扩展性，这样你就通过一个具体的问题，抽象出一个高阶的问题，并且为这个问题提供了一个可行的解决方案了。当然，这种方法的<strong>缺陷</strong>是会占用你很多时间，需要你学习额外的知识。不过，如果是我，我肯定愿意选择这种方式。</p>
<h2 id="帮助团队里的测试">帮助团队里的测试</h2>
<p>我记得我们曾经有一个研发平台项目，其中一个需求是实现租户代码怀味道识别的工具：这个工具的输入是平台上程序员提交的源代码，然后我们的工具会分析类和类之间的关系，然后给代码评定一个分数：比如集成层次不能太深，不能有多继承之类。代码本身并不难写，但是要测试时需要列举很多case，每一个case至少需要可以能编译通过，这要求测试同事还要会写合法的C++代码，也就意味着他们还需要C++的多继承，抽象类之类。</p>
<p>我花了一些时间（两个小时左右）为测试同事写了一个小工具：通过指定一些参数，比如类的继承层次，是否多继承之类，然后这个工具帮你生成一堆合法的可以编译通过的源代码：包括多个文件，文件之间的引用（比如头文件中定义接口，然后在实现代码中访问这些接口等等）。测试可以很容易通过它来生成测试用例，然后再来验证待验证的工具到底能不能识别这些怀味道。</p>
<p><img loading="lazy" src="/images/2018/12/composite-pattern.jpg" type="" alt=""  /></p>
<h3 id="自动化工具">自动化工具</h3>
<p>另外一个有趣的例子是：很久前的一个项目，团队在开发一个大表单，大表单里有很多问题，大概分为三个页面：第一页需要填写一些个人信息，比如姓甚名谁家住何处等，第二页则会填更多的信息，而第二页的很多问题跟第一页相关，一些问题只需要在第一页选了A选项才会出现，而另外一些问题则仅仅为B场景设计等等。</p>
<p>然后某个新需求是在第三页添加一个新的问题（根据第二页的某个回答来决定要不要显示出来）。在实现过程中，开发人员需要手工填很多内容才能到达第三页，而这个过程还可能出错（比如第二页中需要去调用某个API来生成下拉列表内容，那个API有可能会挂掉），一出错又得重来一次（当时还没有HMR啊，State管理啊这些高级货，只能重新刷新）。团队意识到这个痛点之后，有人就开发了一个Chrome的扩展，这个扩展可以根据预设的答案自动填写表单（好像是模拟鼠标点击的方式），直到你想要停下来的那一个问题。这样就将开发中调试的时间大大缩短，还可以节省很多测试同事的工作量。</p>
<p>事实上，这类的场景在实际项目里会有很多。通过一些自己的努力，让团队里的其他角色、或者团队之外的你的下游系统、又或者未来的系统维护者的生活变得轻松一些，是<strong>靠谱</strong>的一个重要表现形式。</p>
<h2 id="做好desk-check">做好Desk Check</h2>
<p>在敏捷开发中，当一个Story开发结束之后，我们会把开发，测试，BA，UX聚在一起来做<code>Shoulder Check / Desk Check</code>。这个实践可能很多团队都会坚持。但是做的流畅程度则千差万别，效果也自然大相径庭。</p>
<p><img loading="lazy" src="/images/2018/12/showcase.jpeg" type="" alt=""  /></p>
<p>我现在还记得第一次做<code>Desk Check</code>时候的忙乱，由于事先没有准备好，当围观群众上来之后，我和peer还没有把<code>Jira</code>上的卡打开。当逐条过验收条件（AC）的时候，我们才发现漏掉了一条。然后在跨浏览器检查的时候，发现在Safari里页面上有个按钮在点击时毫无响应，这时候我和peer打开了<code>dev-tools</code>开始了现场debug等等。</p>
<p>在后来的项目中，我特别注重这个实践，努力让<code>Desk Check</code>变得流畅无碍。你前期准备的越充分，在<code>Desk Check</code>的时候就越顺畅。比如，在把所有人都召集过来之前，自己先把所有AC过一遍，如果有Feature测试的话，就把测试用例大概过一遍，看看能不能覆盖所有AC。在Check的开始前，先把Story描述一遍，特别是业务场景，业务价值。这个过程可以对着Jira卡来过，如果有新的讨论，也需要顺手同步到Jira的comments里，以便未来参考。由于参加<code>Desk Check</code>的QA和BA可能手头都有很多任务并行处理，所以你需要快速的将上下文分享出来，让大家在同一理解水平上，这样后续的Check才有可能顺畅。</p>
<p>如果Story涉及跨浏览器，那么你最好可以将各个浏览器都打开，而且切换到需要<code>showcase</code>的页面上。这些前期的准备工作，可以减少参与者的上下文切换成本，可以让大家迅速进入到验收中，而且出错甚少。事实上，大部分问题在你的准备中都已经解决了，剩余的小问题则可以在后续的Story开发过程中顺手修复。</p>
<h3 id="测试数据准备">测试数据准备</h3>
<p>BA对系统的理解是基于现实世界中的业务来的，因此在数据准备上一定要小心，比如10位数字的身份证号码，带有字母的手机号等等。即使是测试数据，也应该认真对待，尽量避免使用随机的文本来填写表单，否则结果页面看起来会非常不专业。</p>
<p><img loading="lazy" src="/images/2018/12/test-data.png" type="" alt=""  /></p>
<p>在有些场景下，比如你需要测试当文本超过一定长度会显示省略号，你仍然需要仔细设计文本，让其看起来更为实际。当你读到一个名称为“锟斤拷锟斤拷锟斤拷…”的产品时，你会做何感想？</p>
<p>事实上，一些工具可以帮你简化测试数据的准备，而且可以确保专业性。比如Ruby里的Faker（Perl中的Data:Faker的Ruby移植版）https://github.com/stympy/faker，它可以帮你生成很多常见的数据实例，比如</p>
<div class="highlight"><pre class="chroma"><code class="language-rb" data-lang="rb"><span class="nb">require</span> <span class="s1">&#39;faker&#39;</span>

<span class="no">Faker</span><span class="o">::</span><span class="no">Name</span><span class="o">.</span><span class="n">name</span>      <span class="c1">#=&gt; &#34;Christophe Bartell&#34;</span>
<span class="no">Faker</span><span class="o">::</span><span class="no">Bank</span><span class="o">.</span><span class="n">iban</span> <span class="c1">#=&gt; &#34;GB76DZJM33188515981979&#34;</span>
<span class="no">Faker</span><span class="o">::</span><span class="no">Internet</span><span class="o">.</span><span class="n">email</span> <span class="c1">#=&gt; &#34;kirsten.greenholt@corkeryfisher.info”</span>
</code></pre></div><p>使用类似的工具，只需要编写一些微小的代码，就可以生成更贴近业务场景的测试数据，从而让显得更加专业。</p>
<h2 id="设计中的细节">设计中的细节</h2>
<p>同样的道理，UX在设计稿中，需要考虑很多细节，比如</p>
<ul>
<li>常见的拼写错误</li>
<li>业务术语的正确使用</li>
<li>理解数字的含义</li>
<li>视觉一致性（字体的选用，相同元素的字号，颜色暗示等）</li>
</ul>
<p>这些细节可以让观众体会到你的认真和用心，而由于视觉的特殊性，一个微小的纰漏都可能被放大成严重的问题。比如在某一份设计中，所有的标题都采用24号深灰色的<code>Consolas</code>字体，但是在另一处，字号变成了18，而且加粗了。这种错误很容易别识别，从而让人产生不好的印象。</p>
<h3 id="业务语言">业务语言</h3>
<p>而对于用错术语，或者没有完全理解业务时，对数字的解读则会产生更严重的问题。比如在广告行业，广告主比较关心的一个指标是<code>Frequency</code>，计算Frequency的方式是用PV（Page View）/UV（Unique View），也就是每个用户的平均点击量。页面的总访问量肯定比访问这些页面的人数要多（抽屉原理），那么它们的比值也肯定会大于1。如果UX不理解这个业务含义，可能会在设计稿上标识<code>0.68</code>之类的数字。</p>
<p>类似的，如果你在绘制一个<code>Pie Chart</code>，那么最起码所有部分之和加起来要等于100%，而且大致的占比要正确，比如应该避免出现：数值为25%但是视觉上比例却接近1/3等等。</p>
<p><img loading="lazy" src="/images/2018/12/chart.png" type="" alt=""  /></p>
<h3 id="对开发者友好">对开发者友好</h3>
<p>此外，在设计稿中，能为不同的场景设计出相应的变体（variation）也会大大降低开发者和UX之间来回讨论的工作量。比如在一个产品列表的设计中，列表中的第一个条目展示正常情况（happy path），而第二个显示当某些元素缺失时的展现（空值，非法值等），而第三个条目显示当标题超长之后是应该折行还是显示省略号等。</p>
<p>每一个细节事实上都在为你的靠谱程度打分，也会潜在的影响别人是否愿意信赖并乐于与你一同工作。</p>
<h2 id="小结">小结</h2>
<p>文章中列举了一些实际项目中的例子，有关于如何做好开发实践的技巧，有关于帮助团队里的其他人更方便工作的意识，有关于对开发者友好的设计细节。所有这些例子中的技巧，事实上都与这样一个事实有关：要在职场中成为一个靠谱的人，意味着即使对团队内部，你也需要扮演一个<strong>专业服务者</strong>的角色。你需要更多的站在他人的角度来考虑问题，在合理的范围内，尽量的减少别人和你合作时的工作量。此外，你需要处理好很多细节，职业性体现在很多的细节中，从测试数据中的<code>asdfasdf</code>，到设计稿中的typo，都可能暴露你是否在用心对待工作。</p>
<p>文中提及的这些值得践行的技巧事实上与具体技术关联甚弱，你可以很容易的举一反三，并在实际场景中灵活运用，成为一个专业而靠谱的职业人。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>团队里的两类程序员</title>
      <link>https://icodeit.org/2018/01/two-types-of-developer/</link>
      <pubDate>Sun, 14 Jan 2018 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2018/01/two-types-of-developer/</guid>
      <description>程序员的分类 最近几年，我在多个不同类型的项目上，以不同的角色工作过：有时候会为项目前期做一些预研、然后为后续的交付估算工作量；有时候则在项目中期加入团队，做本职的交付工作（就是写业务代码）；而另外有些时候则会帮助客户的团队进行能力建设等等。
由于要在不同的场景和不同的上下文中频繁切换，我和很多不同水平、有着不同变成习惯和思维方式的程序员一起工作过。我觉得对于程序员这样一种角色，还可以再细化成两大类。虽然都是程序员，但是其职责，技能要求，甚至思维方式都可能有很大的不同。
这两大类程序员分别为：
 原型类程序员（prototyper） 产品类程序员（engineer）  原型类程序员 如果通过敏捷的方式来运作一个项目，在项目开始的时候，开发往往需要客户/用户，BA（业务分析师）等角色一起协作。在有一个对需求的粗略梳理之后，通过技术手段快速实现应用程序的原型，用以快速验证业务场景。由于对需求的梳理是较为粗略的，其中有很多待验证的假设，如果按照传统的方式来运作，则会有很多不必要的浪费
 设计师通过Photoshop作出页面 开发根据PS文件来开发 开发的同时，业务分析可能有了新的发现 设计师对Photoshop作出修改 开发根据新的PS来做修改  这种重量级的，瀑布方式的工作体验非常糟糕，不论是设计师，还是开发，总觉得很多事情都在变化，自己花费了很大力气做的像素级别的精准调整可能在第二天就要被推翻。不过现实世界就是这样：需求的变化是不可避免的，我们唯一能做的是积极拥抱变化，而不是在最开始就尝试设计、实现完美的效果。
与其在一开始就试图设计一个完美的、确定的系统，不如放弃幻想，每次只做简陋而可以示意的原型，然后不断去迭代，最后达到可用的系统。
比如，如果设计师完全不使用Photoshop，也不产出任何的PS文件，而是和开发坐在一起，开发一个简陋，但是易于修改（比如HTML+CSS）的页面，然后向业务分析师或者客户来确认，然后根据反馈来快速调整。在迭代过程中，每次确认之前，只做非常少量的工作，这样既可以避免返工，又可以让将来的调整更容易。
如果用这种方式来运作，我们队程序员的能力要求是这样的：
 手速快（可以在很短时间内作出一个可以工作的原型） 技术广博（前后端） 可以与不同角色一起工作（最好是通过结对的方式）  比如通过python -m http.server 8080来运行一个Web服务器，而不是去考虑负载均衡或者HTTP缓存等，也无需考虑在为前端代码加入动态路由。
很有可能，一个在&amp;lt;head&amp;gt;里通过CDN引入外部依赖，然后将所有代码都写入main.js就可以让我们的想法变成触手可及的应用，在建立起快速反馈的机制之后，就可以和我们的BA，甚至客户一起来协作，并快速打磨原型，使之和客户的期望契合。
原型驱动 去年我参加了一个非常有意思的项目，在我加入的时候，客户只有一个非常粗糙的想法：在网络（不是计算机网络）中，如果某个实体被攻击了，那么对整个系统的影响是什么？比如某个变电站由于气温太高爆炸了（6·18西安变电站爆炸事故），那么哪些地铁站会受到影响？以及收到多大影响？又或者某个运营商的网络中断了，那么它对该城市的各大银行的转账业务有多大影响？
客户希望有一个比较直观的方式来展现网络中的节点，以及当故障发生时会有什么样的影响。我们从原型开始，没有设计师的参加，也没有专门的业务分析师，一开始只有有一个简单的文档来描述，然后我根据文档画了一个草图：
和客户确认了，我用bootstrap+leaflet做了一个简单的页面：
客户表示大致是这么个意思。这时候我的代码是这样的：
 一个HTML文件 从CDN来获取jQuery，bootstrap，leaflet inline的script中写了一点微小的代码 inline的css  确定了这就是客户想要的效果之后，我做了一些简单的调整：
 将第三方依赖下载下来，放到本地的一个目录中 将inline的JavaScript和CSS抽取到文件 写了一个简单的shell script用来启停本地的HttpServer  几周之后，客户对右侧的两个panel有一些新的需求，要求有一棵树，可以点击，然后要做各种同步：
这时候，我的代码还是几个微小的jQuery写的文件，通过简单的事件机制来完成交互。很快，客户有了一个新的需求：中间区域的图中的非叶子节点要可点击，点击之后右侧的一个panel显示该节点下的所有叶子，同样，右侧panel中的节点也需要可点击。
也就是说，中间的树需要两个不同的视图，而背后的数据只有一份（这样点击时的展开和收起才会是同步的），这时候用事件机制就很难做到了，而且代码的复杂度直线上升，而且可维护性基本没有。
基本满足客户的需求之后，团队里加入了两位同事，这时候我做了一个比较大胆的决定，用vue.js将整个应用重写，将大部分功能都抽象为组件，方便以后的扩展。完成的时候，界面看起来是这样子的：
如果整理一下思路，原型类开发的流程是这样的：
 用CDN+胶水代码迅速实现 及时与客户沟通，并根据反馈修改 在需求相对稳定，方向确定之后，再做实际的技术选型 重构 — 甚至重写（使用靠谱的技术站进行）  比如上面这个项目，如果现在让我再来做一次技术选型，我可能会这样选择：
 前端框架：React + Redux + React-router 界面原型：AntDesign 地图：Leaflet 可视化：D3  产品类程序员 另一方面，当idea已经经过验证，我们需要通过严谨的工程实践将其产品化，那么对开发的要求却又有不同：</description>
      <content:encoded><![CDATA[<h2 id="程序员的分类">程序员的分类</h2>
<p>最近几年，我在多个不同类型的项目上，以不同的角色工作过：有时候会为项目前期做一些预研、然后为后续的交付估算工作量；有时候则在项目中期加入团队，做本职的交付工作（就是写业务代码）；而另外有些时候则会帮助客户的团队进行能力建设等等。</p>
<p>由于要在不同的场景和不同的上下文中频繁切换，我和很多不同水平、有着不同变成习惯和思维方式的程序员一起工作过。我觉得对于<code>程序员</code>这样一种角色，还可以再细化成两大类。虽然都是程序员，但是其职责，技能要求，甚至思维方式都可能有很大的不同。</p>
<p>这两大类程序员分别为：</p>
<ul>
<li>原型类程序员（prototyper）</li>
<li>产品类程序员（engineer）</li>
</ul>
<h3 id="原型类程序员">原型类程序员</h3>
<p>如果通过敏捷的方式来运作一个项目，在项目开始的时候，开发往往需要客户/用户，BA（业务分析师）等角色一起协作。在有一个对需求的粗略梳理之后，通过技术手段快速实现应用程序的原型，用以快速验证业务场景。由于对需求的梳理是较为粗略的，其中有很多待验证的假设，如果按照传统的方式来运作，则会有很多不必要的浪费</p>
<ol>
<li>设计师通过Photoshop作出页面</li>
<li>开发根据PS文件来开发</li>
<li>开发的同时，业务分析可能有了新的发现</li>
<li>设计师对Photoshop作出修改</li>
<li>开发根据新的PS来做修改</li>
</ol>
<p>这种重量级的，<code>瀑布</code>方式的工作体验非常糟糕，不论是设计师，还是开发，总觉得很多事情都在变化，自己花费了很大力气做的像素级别的精准调整可能在第二天就要被推翻。不过现实世界就是这样：需求的变化是不可避免的，我们唯一能做的是积极拥抱变化，而不是在最开始就尝试设计、实现完美的效果。</p>
<p>与其在一开始就试图设计一个完美的、确定的系统，不如放弃幻想，每次只做简陋而可以示意的原型，然后不断去迭代，最后达到可用的系统。</p>
<p>比如，如果设计师完全不使用<code>Photoshop</code>，也不产出任何的PS文件，而是和开发坐在一起，开发一个简陋，但是易于修改（比如HTML+CSS）的页面，然后向业务分析师或者客户来确认，然后根据反馈来快速调整。在迭代过程中，每次确认之前，只做非常少量的工作，这样既可以避免返工，又可以让将来的调整更容易。</p>
<p>如果用这种方式来运作，我们队程序员的能力要求是这样的：</p>
<ul>
<li>手速快（可以在很短时间内作出一个可以工作的原型）</li>
<li>技术广博（前后端）</li>
<li>可以与不同角色一起工作（最好是通过结对的方式）</li>
</ul>
<p>比如通过<code>python -m http.server 8080</code>来运行一个Web服务器，而不是去考虑负载均衡或者HTTP缓存等，也无需考虑在为前端代码加入动态路由。</p>
<p>很有可能，一个在<code>&lt;head&gt;</code>里通过<code>CDN</code>引入外部依赖，然后将所有代码都写入<code>main.js</code>就可以让我们的想法变成触手可及的应用，在建立起快速反馈的机制之后，就可以和我们的BA，甚至客户一起来协作，并快速打磨原型，使之和客户的期望契合。</p>
<h3 id="原型驱动">原型驱动</h3>
<p>去年我参加了一个非常有意思的项目，在我加入的时候，客户只有一个非常粗糙的想法：在网络（不是计算机网络）中，如果某个实体被攻击了，那么对整个系统的影响是什么？比如某个变电站由于气温太高爆炸了（<a href="https://baike.baidu.com/item/6%C2%B718%E8%A5%BF%E5%AE%89%E5%8F%98%E7%94%B5%E7%AB%99%E7%88%86%E7%82%B8%E4%BA%8B%E6%95%85">6·18西安变电站爆炸事故</a>），那么哪些地铁站会受到影响？以及收到多大影响？又或者某个运营商的网络中断了，那么它对该城市的各大银行的转账业务有多大影响？</p>
<p>客户希望有一个比较直观的方式来展现网络中的节点，以及当故障发生时会有什么样的影响。我们从原型开始，没有设计师的参加，也没有专门的业务分析师，一开始只有有一个简单的文档来描述，然后我根据文档画了一个草图：</p>
<p><img loading="lazy" src="/images/2018/01/prototype-01-resized.png" type="" alt=""  /></p>
<p>和客户确认了，我用<code>bootstrap+leaflet</code>做了一个简单的页面：</p>
<p><img loading="lazy" src="/images/2018/01/prototoype-02-resized.png" type="" alt=""  /></p>
<p>客户表示大致是这么个意思。这时候我的代码是这样的：</p>
<ul>
<li>一个HTML文件</li>
<li>从<code>CDN</code>来获取<code>jQuery</code>，<code>bootstrap</code>，<code>leaflet</code></li>
<li>inline的script中写了一点微小的代码</li>
<li>inline的css</li>
</ul>
<p>确定了这就是客户想要的效果之后，我做了一些简单的调整：</p>
<ul>
<li>将第三方依赖下载下来，放到本地的一个目录中</li>
<li>将inline的<code>JavaScript</code>和<code>CSS</code>抽取到文件</li>
<li>写了一个简单的shell script用来启停本地的HttpServer</li>
</ul>
<p>几周之后，客户对右侧的两个panel有一些新的需求，要求有一棵树，可以点击，然后要做各种同步：</p>
<p><img loading="lazy" src="/images/2018/01/prototype-03-resized.png" type="" alt=""  /></p>
<p>这时候，我的代码还是几个微小的jQuery写的文件，通过简单的事件机制来完成交互。很快，客户有了一个新的需求：中间区域的图中的非叶子节点要可点击，点击之后右侧的一个panel显示该节点下的所有叶子，同样，右侧panel中的节点也需要可点击。</p>
<p>也就是说，中间的树需要两个不同的视图，而背后的数据只有一份（这样点击时的展开和收起才会是同步的），这时候用事件机制就很难做到了，而且代码的复杂度直线上升，而且可维护性基本没有。</p>
<p>基本满足客户的需求之后，团队里加入了两位同事，这时候我做了一个比较大胆的决定，用vue.js将整个应用重写，将大部分功能都抽象为组件，方便以后的扩展。完成的时候，界面看起来是这样子的：</p>
<p><img loading="lazy" src="/images/2018/01/prototype-05-resized.png" type="" alt=""  /></p>
<p>如果整理一下思路，原型类开发的流程是这样的：</p>
<ul>
<li>用<code>CDN</code>+胶水代码迅速实现</li>
<li>及时与客户沟通，并根据反馈修改</li>
<li>在需求相对稳定，方向确定之后，再做实际的技术选型</li>
<li>重构 — 甚至重写（使用靠谱的技术站进行）</li>
</ul>
<p>比如上面这个项目，如果现在让我再来做一次技术选型，我可能会这样选择：</p>
<ul>
<li>前端框架：React + Redux + React-router</li>
<li>界面原型：AntDesign</li>
<li>地图：Leaflet</li>
<li>可视化：D3</li>
</ul>
<h3 id="产品类程序员">产品类程序员</h3>
<p>另一方面，当<code>idea</code>已经经过验证，我们需要通过严谨的工程实践将其产品化，那么对开发的要求却又有不同：</p>
<ul>
<li>非功能需求（安全/性能/容灾等)</li>
<li>深刻而周全</li>
<li>自动化测试</li>
<li>软件架构</li>
</ul>
<p>我在去年的另外一个项目上，负责一个具体模块的开发，一起在项目上有位同事，叫侯晓成。在<code>kick off</code>用户故事（开发和业务分析师，QA等角色一起确认需求，进入开发阶段之前的一个敏捷实践）的时候，他常常可以把BA问的答不上话来。</p>
<p>我们构建的系统需要管理零售中的促销活动，促销活动可以被多个不同的门店执行，这些门店可能位于全球任何一个地方。这时候就会涉及促销活动开始和结束的事件与时区的问题。比如管理员创建了一个圣诞促销，所有商品9折。但是由于时区的存在，各个国家的<code>圣诞节</code>并不是同一天，诸如此类的场景，在编码是都要考虑到。</p>
<p>侯晓成会非常全面的考虑各种业务场景。另一方面，大的系统往往涉及多个集成点，性能、安全，缓存的使用等等，都需要开发人员在编码时就考虑到。为了保证软件的内部质量，程序员还需要有非常好的测试意识和写测试的习惯，不论是比较高层次的集成测试还是更底层单元测试。</p>
<p>除了交付本身，产品型程序员可能还会考虑这样一些工程实践，来保证产品从开发到上线甚至到运维的各个方面：</p>
<ul>
<li>持续集成、持续交付</li>
<li>自动化测试</li>
<li>DevOps</li>
</ul>
<p><img loading="lazy" src="/images/2016/02/knowledge-framework.png" type="" alt=""  /></p>
<h3 id="小结">小结</h3>
<p>毫无疑问，我们在实际项目中，这两种程序员都是缺一不可，相互补充的。在需求还没有完全明朗，需要快速验证市场，探索业务方向的正确性，我们需要原型类程序员。他们通过和业务分析师，设计师等角色一起工作，可以快速且轻量级的迭代出产品的原型。而一旦市场基本确定，我们就需要产品型程序员的帮助，将产品的开发、测试、部署、运维整个生命周期都规范化，引入相对重量且长期的工程实践，这样产品在后续的迭代中才可能保持非常高的内部质量。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>反馈拯救世界</title>
      <link>https://icodeit.org/2018/01/feedback-saves-the-world/</link>
      <pubDate>Sat, 13 Jan 2018 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2018/01/feedback-saves-the-world/</guid>
      <description>心流 你可能有过这样的体验：在玩一个很有趣的游戏时，时间会飞快的流逝，等你终于通关之后才发现已经是凌晨，而你的午饭和晚饭还都没吃。虽然可能饿着肚子，但是你内心却有一种很兴奋，很神清气爽的感觉。而当你在做一些不得不完成的工作/作业时（比如写年终总结报告），时间又会过得很慢，你的心情也常常变得焦虑或者暴躁。
通常来说，人的心情总是会在各种情绪中起伏不定，不过毋庸置疑，我们都希望永远或者至少是尽可能多的保持第一个场景中的状态。
这种精神高度集中，通过自己的努力不断完成挑战，并常常会有忘记时间流逝，甚至忘记自身存在，只剩下“做事情”本身的状态，在心理学上被称之为心流（Flow）。人们虽然很早就发现了这种现象，但是直到1975年，心理学家米哈里·齐克森米哈里（Mihaly Csikszentmihalyi）才将其概念化并通过科学的方式来研究。
 心流（英语：Flow），也有别名以化境(Zone)表示，亦有人翻译为神驰状态，定义是一种将个人精神力完全投注在某种活动上的感觉；心流产生时同时会有高度的兴奋及充实感。
 进入心流之后会有很多特征：
 愉悦 全身心投入 忘我，与做的事情融为一体 主观的时间感改变  心流被普遍认为是一种绝佳的精神体验。根据齐克森米哈里的理论，与心流对应的，还有一些其他的心理状态：
当自身能力很高，但是做的事情很简单的话，你做起来会比较无聊；而当能力不足，要做的事情很困难的话，你又会陷入焦虑。有意思的是，如果你技能不足，而做的事情又比较简单的话，并不会产生“心流”体验。恰恰相反，这种状态（apathy）是很消极的，做事情的过程中，你既没有运用任何技能，也并没有接受到任何的挑战。
如何进入心流状态 齐克森米哈里要进入心流状态，需要满足至少三点：
 有清晰的目标 有明确且事实的反馈 能力和挑战的平衡（都处于比较高的状态）  比如，玩游戏的时候，目标是明确的，不论是简单的通过策略消灭对方，还是将三个同一颜色的宝石移动到同一行）；反馈也是实时的，同色宝石连在一起是发出的声音以及屏幕上闪过的炫目的光芒，敌人在被你手中武器杀死时的惨叫，你自己的血槽等等；最后，游戏不能过于简单，如果太简单，你很快会觉得无聊，又不能太难，这样你会觉得挑战太大。
不过要在工作上进入心流状态，远远比玩游戏要复杂。比如不明确的目标，冗长的反馈周期，能力与挑战的不均衡等等。
基于反馈的开发 2014年底，我在ThoughtWorks组织3周3页面工作坊的时候，发现了一个很有意思的现象：通常公司内部的培训/工作坊都会出现这种现象：报名的人很多，前几次课会来很多人，慢慢的人数会减少，能坚持到最后的人很少，能完成作业的就更少了。而在3周3页面中，参加的人数越来越多，而且作业的完成率非常高（接近100%）。
回想起来，我在培训的最开始就设置了一些机制，保证学员可以有一个非常容易沉浸其中的环境：
 通过watch、livereload等机制，保证每次修改的CSS/HTML都可以在1秒钟内在浏览器上自动刷新 通过对比mockup和自己实现的样式的差异，来调整自己的目标 将这些工具做成开箱即用的，这样经验不足者不至于被技术细节阻塞 做完之后，学员们的作品直接发布到github的pages上  事实上，这些实践恰好满足了上述的几个条件：
 目标明确 快速且准确的反馈 技能与挑战的平衡  由于工作坊是在周内下班后（8点结束），我见到很多学员在课后（很晚的时候）还在写代码、调样式，完全沉浸其中，忘记时间。到最后，参加培训的学员们被要求通过设计原则自己实际一个Web Site，很多没有前段开发背景的同事也做出了非常有“设计感”的作品。
编程语言的壁垒 使用JavaScript或者Ruby这种解释型语言的开发人员，在第一次接触之后就会深深的爱上它，并再也无法回到编译型语言中去了。想一想要用Java打印一行Hello World你得费多大劲？
解释型语言中，你很容易可以采用REPL环境，写代码会变成一个做实验的过程：函数名写错了，参数传错了，某个函数没有定义等等错误/手误，都可以在1秒钟内得到反馈，然后你再根据反馈来修正方向。
举个小例子，写一个字符串处理函数：将字符串”qiu,juntao”转换成“Qiu Juntao”，你会怎么做？你大概知道有这样一些原生的API：
 String.indexOf String.replace 大小写转换 正则表达式（可选）  如果用JavaScript来实现的话，你可以在Chrome的DevTools中完成大部分的工作：
注意这里的每次操作的反馈（特别是出错的情况），你可以在1秒钟内就知道明确的反馈，而不是等等待漫长的编译过程。DevTools里的console提供的REPL（read-eval-print-loop）可以帮助你建立流畅的编码体验。
如果用Java来做，你需要一大堆的准备工作，抛开JDK的安装，JAVA_HOME的设置等，你还需要编译代码，需要定义一个类，然后在类中定义main方法，然后可能要查一些API来完成函数的编写。而每一个额外的步骤都会延长反馈的时间。
测试驱动开发 那么在编译型语言中如何获得这种体验呢？又如何缩短反馈周期呢？答案是使用测试驱动开发（Test Driven Development）！
通常TDD会包含这样几个步骤：
 根据用户故事做任务分解 根据分解后的Task设计测试 编写测试 编写可以通过测试的实现 重构  步骤3-5可能会不断重复，直到所有的Task都完成，用户故事也就完成了。如果仔细分析，这些步骤也恰好符合产生心流的条件：</description>
      <content:encoded><![CDATA[<h3 id="心流">心流</h3>
<p>你可能有过这样的体验：在玩一个很有趣的游戏时，时间会飞快的流逝，等你终于通关之后才发现已经是凌晨，而你的午饭和晚饭还都没吃。虽然可能饿着肚子，但是你内心却有一种很兴奋，很神清气爽的感觉。而当你在做一些不得不完成的工作/作业时（比如写年终总结报告），时间又会过得很慢，你的心情也常常变得焦虑或者暴躁。</p>
<p>通常来说，人的心情总是会在各种情绪中起伏不定，不过毋庸置疑，我们都希望永远或者至少是尽可能多的保持第一个场景中的状态。</p>
<p><img loading="lazy" src="/images/2018/01/playing-game-resized.png" type="" alt=""  /></p>
<p>这种精神高度集中，通过自己的努力不断完成挑战，并常常会有忘记时间流逝，甚至忘记自身存在，只剩下“做事情”本身的状态，在心理学上被称之为<a href="https://en.wikipedia.org/wiki/Flow_(psychology)">心流（Flow）</a>。人们虽然很早就发现了这种现象，但是直到1975年，心理学家米哈里·齐克森米哈里（<a href="https://en.wikipedia.org/wiki/Mih%C3%A1ly_Cs%C3%ADkszentmih%C3%A1lyi">Mihaly Csikszentmihalyi</a>）才将其概念化并通过科学的方式来研究。</p>
<blockquote>
<p>心流（英语：Flow），也有别名以化境(Zone)表示，亦有人翻译为神驰状态，定义是一种将个人精神力完全投注在某种活动上的感觉；心流产生时同时会有高度的兴奋及充实感。</p>
</blockquote>
<p>进入心流之后会有很多特征：</p>
<ul>
<li>愉悦</li>
<li>全身心投入</li>
<li>忘我，与做的事情融为一体</li>
<li>主观的时间感改变</li>
</ul>
<p>心流被普遍认为是一种绝佳的精神体验。根据齐克森米哈里的理论，与心流对应的，还有一些其他的心理状态：</p>
<p><img loading="lazy" src="/images/2018/01/300px-Challenge_vs_skill.svg.png" type="" alt=""  /></p>
<p>当自身能力很高，但是做的事情很简单的话，你做起来会比较无聊；而当能力不足，要做的事情很困难的话，你又会陷入焦虑。有意思的是，如果你技能不足，而做的事情又比较简单的话，并不会产生“心流”体验。恰恰相反，这种状态（<strong>apathy</strong>）是很消极的，做事情的过程中，你既没有运用任何技能，也并没有接受到任何的挑战。</p>
<h3 id="如何进入心流状态">如何进入心流状态</h3>
<p>齐克森米哈里要进入心流状态，需要满足至少三点：</p>
<ul>
<li>有清晰的目标</li>
<li>有明确且事实的反馈</li>
<li>能力和挑战的平衡（都处于比较高的状态）</li>
</ul>
<p>比如，玩游戏的时候，目标是明确的，不论是简单的通过策略消灭对方，还是将三个同一颜色的宝石移动到同一行）；反馈也是实时的，同色宝石连在一起是发出的声音以及屏幕上闪过的炫目的光芒，敌人在被你手中武器杀死时的惨叫，你自己的血槽等等；最后，游戏不能过于简单，如果太简单，你很快会觉得无聊，又不能太难，这样你会觉得挑战太大。</p>
<p>不过要在工作上进入心流状态，远远比玩游戏要复杂。比如不明确的目标，冗长的反馈周期，能力与挑战的不均衡等等。</p>
<h3 id="基于反馈的开发">基于反馈的开发</h3>
<p>2014年底，我在<code>ThoughtWorks</code>组织<a href="http://icodeit.org/3-pages-in-3-weeks/">3周3页面</a>工作坊的时候，发现了一个很有意思的现象：通常公司内部的培训/工作坊都会出现这种现象：报名的人很多，前几次课会来很多人，慢慢的人数会减少，能坚持到最后的人很少，能完成作业的就更少了。而在<a href="http://icodeit.org/3-pages-in-3-weeks/">3周3页面</a>中，参加的人数越来越多，而且作业的完成率非常高（接近100%）。</p>
<p>回想起来，我在培训的最开始就设置了一些机制，保证学员可以有一个非常容易沉浸其中的环境：</p>
<ul>
<li>通过watch、livereload等机制，保证每次修改的CSS/HTML都可以在1秒钟内在浏览器上自动刷新</li>
<li>通过对比mockup和自己实现的样式的差异，来调整自己的目标</li>
<li>将这些工具做成<a href="https://github.com/abruzzi/design-boilerplate">开箱即用</a>的，这样经验不足者不至于被技术细节阻塞</li>
<li>做完之后，学员们的作品直接发布到<a href="https://pages.github.com/">github的pages</a>上</li>
</ul>
<p><img loading="lazy" src="/images/2018/01/3p3w-resized.png" type="" alt=""  /></p>
<p>事实上，这些实践恰好满足了上述的几个条件：</p>
<ul>
<li>目标明确</li>
<li>快速且准确的反馈</li>
<li>技能与挑战的平衡</li>
</ul>
<p>由于工作坊是在周内下班后（8点结束），我见到很多学员在课后（很晚的时候）还在写代码、调样式，完全沉浸其中，忘记时间。到最后，参加培训的学员们被要求通过设计原则自己实际一个Web Site，很多没有前段开发背景的同事也做出了非常有“设计感”的作品。</p>
<p><img loading="lazy" src="/images/2018/01/3p3w-showcase-resized.png" type="" alt=""  /></p>
<h3 id="编程语言的壁垒">编程语言的壁垒</h3>
<p>使用<code>JavaScript</code>或者<code>Ruby</code>这种解释型语言的开发人员，在第一次接触之后就会深深的爱上它，并再也无法回到编译型语言中去了。想一想要用<code>Java</code>打印一行<code>Hello World</code>你得费多大劲？</p>
<p>解释型语言中，你很容易可以采用<a href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a>环境，写代码会变成一个做实验的过程：函数名写错了，参数传错了，某个函数没有定义等等错误/手误，都可以在1秒钟内得到反馈，然后你再根据反馈来修正方向。</p>
<p>举个小例子，写一个字符串处理函数：将字符串”qiu,juntao”转换成“Qiu Juntao”，你会怎么做？你大概知道有这样一些原生的API：</p>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf">String.indexOf</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace">String.replace</a></li>
<li><a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase">大小写转换</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp">正则表达式</a>（可选）</li>
</ul>
<p>如果用JavaScript来实现的话，你可以在<code>Chrome</code>的<code>DevTools</code>中完成大部分的工作：</p>
<p><img loading="lazy" src="/images/2018/01/chrome-dev-tools-resized.png" type="" alt=""  /></p>
<p>注意这里的每次操作的反馈（特别是出错的情况），你可以在1秒钟内就知道明确的反馈，而不是等等待漫长的编译过程。DevTools里的console提供的REPL（read-eval-print-loop）可以帮助你建立流畅的编码体验。</p>
<p>如果用<code>Java</code>来做，你需要一大堆的准备工作，抛开<code>JDK</code>的安装，<code>JAVA_HOME</code>的设置等，你还需要编译代码，需要定义一个类，然后在类中定义main方法，然后可能要查一些API来完成函数的编写。而每一个额外的步骤都会延长反馈的时间。</p>
<h3 id="测试驱动开发">测试驱动开发</h3>
<p>那么在编译型语言中如何获得这种体验呢？又如何缩短反馈周期呢？答案是使用<strong>测试驱动开发</strong>（Test Driven Development）！</p>
<p>通常<code>TDD</code>会包含这样几个步骤：</p>
<ol>
<li>根据用户故事做任务分解</li>
<li>根据分解后的<code>Task</code>设计测试</li>
<li>编写测试</li>
<li>编写可以通过测试的实现</li>
<li>重构</li>
</ol>
<p><img loading="lazy" src="/images/2018/01/tasking-resized.png" type="" alt=""  /></p>
<p>步骤3-5可能会不断重复，直到所有的Task都完成，用户故事也就完成了。如果仔细分析，这些步骤也恰好符合产生心流的条件：</p>
<ul>
<li>划分任务</li>
<li>清晰每一个小任务</li>
<li>通过测试得到快速而明确的反馈</li>
</ul>
<p>虽然对上边字符串转换的例子来说，<code>TDD</code>的方式还是比较重量级，不过反馈更明确，你可以在写完一个函数之后立即得到测试成功或者失败的反馈（编译过程并没有省略，不过我们通过测试的红和绿来不断强化反馈）。</p>
<p>而且这种方法的好处在于：对于更加复杂的需求来说，它仍然适用。如果开发者的技能和需求的难度都比较高的话，这种方式很容易达到心流的状态。</p>
<h3 id="小结">小结</h3>
<p>要想在工作中让自己过得更舒服一些，你需要创造条件让自己进入心流状态。在这些条件中，最重要的是要建立其一套快速反馈的机制，这个机制可以是：</p>
<ul>
<li>一个可以自动运行的测试套件</li>
<li>一个可以迭代的页面原型</li>
<li>一个watch所有HTML/SCSS的脚本+live-reload</li>
<li>一个和你一起写代码的同事（结对编程）</li>
</ul>
<p><img loading="lazy" src="/images/2018/01/gulp-serve-resized.png" type="" alt=""  /></p>
<p>另一方面，你需要不断的学习和练习，提升自己的技能，这样在遇到新的问题时才可能比较从容应对。不要忘了，<strong>更熟练的技能</strong>本身也是进入心流的重要条件之一。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>给新人程序员的一些建议</title>
      <link>https://icodeit.org/2017/07/tips-for-newbies/</link>
      <pubDate>Tue, 25 Jul 2017 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2017/07/tips-for-newbies/</guid>
      <description>作为一个从业快10年的程序员，我想给新入行的程序员们一些建议。这些建议是我希望自己可以在毕业的时候就读到的，也希望它们可以帮助你成为一个更好的程序员。
简单归纳一下，总共有7条：
 保持健康 编程之外的爱好 持续学习 正确应对犯错 不要囿于角色 展示你的创意 刻意练习手速  下面我来详细说说每一点。
保持健康  三寸气在千般用，一旦无常万事休
&amp;ndash;《金瓶梅》
 首先要说的当然是健康，脱离的这个本钱，一切都无从谈起。久坐、不运动、睡眠不足、不注意及时补充水分、长期的伏案工作会对健康造成很大的影响，而不幸的是程序员这几样全都占了。很多程序员往往很年轻就已经有了各种各样的疾病：颈椎病、腰椎间盘突出、高血脂/高血压、胆结石、腱鞘炎等等，关于程序员过劳死的新闻更是隔一段时间就来刺激一下我们的神经。
研究表明，长期保持同一姿势（不论坐着还是站着）对身体都有不同程度的害处，而且这种害处是无法事后弥补的。也就是说，如果白天上班坐8个小时，那么就算你下班后去健身房练一个小时也于事无补。这几年很流行的站立式办公也是一样，如果你白天站立时间过久，会对膝关节造成较大的压力，同样会损害健康。比较推荐的方式是，写30-40分钟代码就起来走一走，喝杯水，远眺一会，跟同事聊聊天。
我知道，作为程序员我也常遇到那种写代码写High了连厕所也不想去的时候。不过为了长远的健康，还是要养成良好的习惯。
戒除不良习惯 除了长时间保持同一姿势之外，有很多程序员还有各种不良习惯。比如：
 吸烟 喝酒 嗜糖（碳酸饮料，其他高糖饮料）  这些习惯一般都会美其名曰提神，大家都知道，程序员加班在业界算是比较常见的，萎靡不振是常态。然而这些号称提神的方法，其实没有一个是真正管用的。这些不良习惯说到底都是一种毒瘾，跟吸食大麻在本质上并无二致。不过好消息是你完全可以戒除这些不良习惯，只需要坚持一段时间，让毒瘾过去就好了（和真正的毒瘾一样，它们更多的是精神依赖，一旦你战胜了自己对它的精神依赖，就可以获得自由）。
我在大学和刚开始工作的前几年，也有烟瘾。写代码写累了就回去办公室外边冒一根，那种一氧化碳中毒带来的短暂的微醺感确实令人有放松的错觉，但是抽完烟回来写代码会感觉更累。而且口中老感觉有异味，咽喉不适，最主要的是精神萎靡，终于有一天我受不了了，决定戒烟（事实上和很多人一样，之前也有过无数次的戒烟）。当烟瘾发作的时候，我就去喝杯水，晚上则站站桩（站完之后口齿生津，神清气爽）。刚开始的3天是最难的，一周之后我就基本可以控制住去抽烟的欲望，然后就越来越轻松，完全感觉不到烟瘾对我的影响了。
碳酸饮料，高糖饮料也是一样。在饮食本来就不充裕的自然界，我们的祖先遇到了富含可以为身体提供能量的糖（比如蜂蜜）自然会大量摄入。这种嗜糖的基因在今天还在不断的产生作用，但是不同的是，我们现在可以很轻松的在食物、饮料中摄入比身体所需多得多的糖。这些糖会给健康带来很多问题，比如肥胖，高血糖，冠心病等等。
更多时候，我们想要喝饮料更多的是精神上的依赖，也就是上面说到的毒瘾。戒除对糖的依赖比烟和酒要困难一些，因为生活中有很多陷阱，比如酸奶，面包，饼干，水果等等。
零度可乐的陷阱 现在香烟的包装上印有焦油含量，有10mg的，有15mg的。焦油含量是影响一支烟口感的重要因素，通常说的“绵”其实是说焦油含量角度，这会让你感觉比较健康。然而陷阱是，一支烟抽完觉得不过瘾，神经感受到的刺激不够强烈，这会驱动你抽第二支，结果吸入的焦油反而更多。本来15mg焦油的一支烟就可以让你过瘾，现在两支10mg的才能达到同样的效果，相当于摄入了20mg。
零度可乐也是一样，那种无糖的有着甜味的添加剂会刺激你对糖的渴求，你需要摄入更多的糖来抵消这种虚幻的渴求 &amp;ndash; 然后变得更不健康。
有人可能会说，没有这些嗜好，那活着有什么意思呢？相信我，当你戒除了这些毒瘾，有了一个健康的体魄，才真正能体会到活着的乐趣。当你为这些嗜好所控制，产生的那种病态的舒适感其实是虚无缥缈的。
一些建议 有规律的做一些运动，可以缓解颈椎，腰椎的不适，可以加快新陈代谢的速度，消耗多余的会沉积下来的能量。比如比较容易接触到，也容易上手的运动：
 瑜伽/普拉提 乒乓球 跳绳  选择一个适合自己的运动方式，然后将其培养成一个习惯（比如坚持每周两次瑜伽，或者每天中午打30分钟的乒乓球）。如果这些和工作有冲突的话，比如公司要求长期晚上加班，那你可以考虑换一家公司。
培养一个编程之外的爱好 如果让不同的人对程序员打标签并排序，宅一定会排在前三。在任何的聚会上，程序员总是很容易被识别出来的：聪明，戴眼镜，话不多，略显闷骚，聊天容易冷场等等。也难怪，长期钻研技术，沉浸在非黑即白的二进制世界，爱刨根问底，这样很容易把天聊死。
我建议新手程序员可以找一个编程之外的爱好，一来可以拓展自己的社交圈，周末可以有个不一样的过法（而不是宅在家里写代码）；二来可以帮助你成为更好的程序员。
你肯定有过这样的经历：一个编程问题一直困扰着你，试了很久都找不到解决方法，结果出去散了会步，或者和别人唠家常，突然脑海里灵光一闪，想到了问题的答案。事实上，我们大脑的工作方式就是如此奇妙，换一个完全不同的上下文就可以让大脑得到很好的休息，而且往往可以产生1+1&amp;gt;2的效果。写代码写累了去听听音乐，或者打一会乒乓球就可以很好的缓解疲劳，甚至可以打开思路，产生新的灵感。
一些建议 学习一项与编程无关的技能，比如：
 乐器（比如吉他，架子鼓） 绘画（素描，水粉，水彩等）或者书法 制作美食 某一项武术（拳击，泰拳，空手道等）  这些看似毫不相干的爱好可以帮助大脑休息。另外需要注意的是，你无需真正成为某一项爱好的专家，不要有额外的压力：担心演奏不好、没有绘画天赋等等。没关系，它只是一个爱好而已。
我自己就尝试过很多不同的爱好，比如素描、书法等。
持续学习 软件开发是一个需要终身学习的行业（其实如果你不想做那种混吃等死的人的话，基本上每个行业都是这样）。我毕业的时候，SSH（Spring Struts Hibernate）是Web开发的主流，jQuery则是前端的新锐。有一些企业开始尝试Adobe的ActionScript，不过这个语言很快就消逝在了人们的视野。基于jQUery，但是融入了MVC理念的Backbone.js提供更高级的抽象能力，成为了开发“大型”前端应用的首选；紧随其后的，大而全的Angular.js则通过内置的双向绑定，依赖注入，完善的测试支持等让前端开发变得和后端开发一样健全；再后来虚拟DOM，Reactive范式的React栈则又一次颠覆了前端的开发方式。虽然现在还不知道下一次的颠覆会在哪里发生，但是可以肯定的是它一定会发生。
除了基础框架之外，各种构建工具也是层出不穷，从最早和后端放在一起的maven，rake，到基于NodeJS的grunt，再到gulp，到webpack，最后又回归到npm script。
程序员被裹挟在技术演进的洪流中，不能自已。作为程序员，你不但要非常扎实的掌握基础知识（操作系统原理，计算机网络，数据结构，算法等），还需要有非常强的快速学习能力，以及愿意不断去学习的态度，而后者可能更重要。
一些建议  读书 通过视频/文本教程等学习新技术  建议新手可以每天抽出一个小时来读书，周末可以多读一些。ThoughtWorks有个读书雷达，是一个很不错的书单，包括了很多的经典书籍。读书之外，还可以在线学习一些教程，比如Tutorialplus和Egghead等，都非常值得经常去看看，如果有比较新鲜有趣的技术，不妨自己亲自动手试一试。</description>
      <content:encoded><![CDATA[<p>作为一个从业快10年的程序员，我想给新入行的程序员们一些建议。这些建议是我希望自己可以在毕业的时候就读到的，也希望它们可以帮助你成为一个更好的程序员。</p>
<p>简单归纳一下，总共有7条：</p>
<ol>
<li>保持健康</li>
<li>编程之外的爱好</li>
<li>持续学习</li>
<li>正确应对犯错</li>
<li>不要囿于角色</li>
<li>展示你的创意</li>
<li>刻意练习手速</li>
</ol>
<p>下面我来详细说说每一点。</p>
<h2 id="保持健康">保持健康</h2>
<blockquote>
<p>三寸气在千般用，一旦无常万事休</p>
<p>&ndash;《金瓶梅》</p>
</blockquote>
<p>首先要说的当然是健康，脱离的这个本钱，一切都无从谈起。久坐、不运动、睡眠不足、不注意及时补充水分、长期的伏案工作会对健康造成很大的影响，而不幸的是程序员这几样全都占了。很多程序员往往很年轻就已经有了各种各样的疾病：颈椎病、腰椎间盘突出、高血脂/高血压、胆结石、腱鞘炎等等，关于程序员过劳死的新闻更是隔一段时间就来刺激一下我们的神经。</p>
<p>研究表明，长期保持同一姿势（不论坐着还是站着）对身体都有不同程度的害处，而且这种害处是无法事后弥补的。也就是说，如果白天上班坐8个小时，那么就算你下班后去健身房练一个小时也于事无补。这几年很流行的<em>站立式办公</em>也是一样，如果你白天站立时间过久，会对膝关节造成较大的压力，同样会损害健康。比较推荐的方式是，写30-40分钟代码就起来走一走，喝杯水，远眺一会，跟同事聊聊天。</p>
<p>我知道，作为程序员我也常遇到那种写代码写High了连厕所也不想去的时候。不过为了长远的健康，还是要养成良好的习惯。</p>
<h3 id="戒除不良习惯">戒除不良习惯</h3>
<p>除了长时间保持同一姿势之外，有很多程序员还有各种不良习惯。比如：</p>
<ul>
<li>吸烟</li>
<li>喝酒</li>
<li>嗜糖（碳酸饮料，其他高糖饮料）</li>
</ul>
<p>这些习惯一般都会美其名曰<strong>提神</strong>，大家都知道，程序员加班在业界算是比较常见的，萎靡不振是常态。然而这些号称提神的方法，其实没有一个是真正管用的。这些不良习惯说到底都是一种<em>毒瘾</em>，跟吸食大麻在本质上并无二致。不过好消息是你完全可以戒除这些不良习惯，只需要坚持一段时间，让<em>毒瘾</em>过去就好了（和真正的毒瘾一样，它们更多的是精神依赖，一旦你战胜了自己对它的精神依赖，就可以获得自由）。</p>
<p>我在大学和刚开始工作的前几年，也有烟瘾。写代码写累了就回去办公室外边冒一根，那种一氧化碳中毒带来的短暂的微醺感确实令人有放松的错觉，但是抽完烟回来写代码会感觉更累。而且口中老感觉有异味，咽喉不适，最主要的是精神萎靡，终于有一天我受不了了，决定戒烟（事实上和很多人一样，之前也有过无数次的戒烟）。当烟瘾发作的时候，我就去喝杯水，晚上则站站桩（站完之后口齿生津，神清气爽）。刚开始的3天是最难的，一周之后我就基本可以控制住去抽烟的欲望，然后就越来越轻松，完全感觉不到烟瘾对我的影响了。</p>
<p>碳酸饮料，高糖饮料也是一样。在饮食本来就不充裕的自然界，我们的祖先遇到了富含可以为身体提供能量的糖（比如蜂蜜）自然会大量摄入。这种嗜糖的基因在今天还在不断的产生作用，但是不同的是，我们现在可以很轻松的在食物、饮料中摄入比身体所需<strong>多得多</strong>的糖。这些糖会给健康带来很多问题，比如肥胖，高血糖，冠心病等等。</p>
<p><img loading="lazy" src="/images/2017/07/sugar-resized.png" type="" alt=""  /></p>
<p>更多时候，我们想要喝饮料更多的是精神上的依赖，也就是上面说到的<em>毒瘾</em>。戒除对糖的依赖比烟和酒要困难一些，因为生活中有很多陷阱，比如酸奶，面包，饼干，水果等等。</p>
<h3 id="零度可乐的陷阱">零度可乐的陷阱</h3>
<p>现在香烟的包装上印有焦油含量，有10mg的，有15mg的。焦油含量是影响一支烟口感的重要因素，通常说的“绵”其实是说焦油含量角度，这会让你感觉比较健康。然而陷阱是，一支烟抽完觉得不过瘾，神经感受到的刺激不够强烈，这会驱动你抽第二支，结果吸入的焦油反而更多。本来15mg焦油的一支烟就可以让你过瘾，现在两支10mg的才能达到同样的效果，相当于摄入了20mg。</p>
<p>零度可乐也是一样，那种无糖的有着甜味的添加剂会刺激你对糖的渴求，你需要摄入更多的糖来抵消这种虚幻的渴求 &ndash; 然后变得更不健康。</p>
<p>有人可能会说，没有这些嗜好，那活着有什么意思呢？相信我，当你戒除了这些毒瘾，有了一个健康的体魄，才真正能体会到活着的乐趣。当你为这些嗜好所控制，产生的那种病态的舒适感其实是虚无缥缈的。</p>
<h3 id="一些建议">一些建议</h3>
<p>有规律的做一些运动，可以缓解颈椎，腰椎的不适，可以加快新陈代谢的速度，消耗多余的会沉积下来的能量。比如比较容易接触到，也容易上手的运动：</p>
<ul>
<li>瑜伽/普拉提</li>
<li>乒乓球</li>
<li>跳绳</li>
</ul>
<p>选择一个适合自己的运动方式，然后将其培养成一个习惯（比如坚持每周两次瑜伽，或者每天中午打30分钟的乒乓球）。如果这些和工作有冲突的话，比如公司要求长期晚上加班，那你可以考虑换一家公司。</p>
<h2 id="培养一个编程之外的爱好">培养一个编程之外的爱好</h2>
<p>如果让不同的人对程序员打标签并排序，<strong>宅</strong>一定会排在前三。在任何的聚会上，程序员总是很容易被识别出来的：聪明，戴眼镜，话不多，略显闷骚，聊天容易冷场等等。也难怪，长期钻研技术，沉浸在非黑即白的二进制世界，爱刨根问底，这样很容易把天聊死。</p>
<p>我建议新手程序员可以找一个编程之外的爱好，一来可以拓展自己的社交圈，周末可以有个不一样的过法（而不是宅在家里写代码）；二来可以帮助你成为更好的程序员。</p>
<p>你肯定有过这样的经历：一个编程问题一直困扰着你，试了很久都找不到解决方法，结果出去散了会步，或者和别人唠家常，突然脑海里灵光一闪，想到了问题的答案。事实上，我们大脑的工作方式就是如此奇妙，换一个完全不同的上下文就可以让大脑得到很好的休息，而且往往可以产生<code>1+1&gt;2</code>的效果。写代码写累了去听听音乐，或者打一会乒乓球就可以很好的缓解疲劳，甚至可以打开思路，产生新的灵感。</p>
<h3 id="一些建议-1">一些建议</h3>
<p>学习一项与编程无关的技能，比如：</p>
<ul>
<li>乐器（比如吉他，架子鼓）</li>
<li>绘画（素描，水粉，水彩等）或者书法</li>
<li>制作美食</li>
<li>某一项武术（拳击，泰拳，空手道等）</li>
</ul>
<p>这些看似毫不相干的爱好可以帮助大脑休息。另外需要注意的是，你无需真正成为某一项爱好的专家，不要有额外的压力：担心演奏不好、没有绘画天赋等等。没关系，它只是一个爱好而已。</p>
<p><img loading="lazy" src="/images/2017/07/drawing-resized.png" type="" alt=""  /></p>
<p>我自己就尝试过很多不同的爱好，比如素描、书法等。</p>
<h2 id="持续学习">持续学习</h2>
<p>软件开发是一个需要终身学习的行业（其实如果你不想做那种混吃等死的人的话，基本上每个行业都是这样）。我毕业的时候，<code>SSH</code>（Spring Struts Hibernate）是Web开发的主流，<code>jQuery</code>则是前端的新锐。有一些企业开始尝试<code>Adobe</code>的<code>ActionScript</code>，不过这个语言很快就消逝在了人们的视野。基于<code>jQUery</code>，但是融入了<code>MVC</code>理念的<code>Backbone.js</code>提供更高级的抽象能力，成为了开发“大型”前端应用的首选；紧随其后的，大而全的<code>Angular.js</code>则通过内置的双向绑定，依赖注入，完善的测试支持等让前端开发变得和后端开发一样健全；再后来<code>虚拟DOM</code>，<code>Reactive范式</code>的<code>React</code>栈则又一次颠覆了前端的开发方式。虽然现在还不知道下一次的颠覆会在哪里发生，但是可以肯定的是它<strong>一定会发生</strong>。</p>
<p>除了基础框架之外，各种构建工具也是层出不穷，从最早和后端放在一起的<code>maven</code>，<code>rake</code>，到基于<code>NodeJS</code>的<code>grunt</code>，再到<code>gulp</code>，到<code>webpack</code>，最后又回归到<code>npm script</code>。</p>
<p>程序员被裹挟在技术演进的洪流中，不能自已。作为程序员，你不但要非常扎实的掌握基础知识（操作系统原理，计算机网络，数据结构，算法等），还需要有非常强的快速学习能力，以及愿意不断去学习的态度，而后者可能更重要。</p>
<p><img loading="lazy" src="/images/2016/02/knowledge-framework.png" type="" alt=""  /></p>
<h3 id="一些建议-2">一些建议</h3>
<ul>
<li>读书</li>
<li>通过视频/文本教程等学习新技术</li>
</ul>
<p>建议新手可以每天抽出一个小时来读书，周末可以多读一些。ThoughtWorks有个<a href="http://insights.thoughtworkers.org/reading-radar-2016/">读书雷达</a>，是一个很不错的书单，包括了很多的经典书籍。读书之外，还可以在线学习一些教程，比如<a href="https://tutsplus.com/">Tutorialplus</a>和<a href="https://egghead.io/">Egghead</a>等，都非常值得经常去看看，如果有比较新鲜有趣的技术，不妨自己亲自动手试一试。</p>
<h3 id="关于英文能力">关于英文能力</h3>
<p>毫不夸张的说，英文能力是优秀程序员和普通程序员的华丽分割线。有了好的英文能力，可供你学习的资料库会立刻扩大数百甚至数千倍：海量的优质免费教程，视频。很优秀的中文教程一样，它们都深入浅出，通俗易懂，风趣幽默，只不过中文的会比较少，而且一般总是会滞后于英文版本而已。</p>
<p>英文能力不但可以帮你熟悉各种前端库，CSS框架等的介绍。还可以让你学习世界各国程序员对各种库的测评、框架的使用心得、踩过的坑等等。</p>
<p>我在2012年加入ThoughtWorks的时候，面试时磕磕绊绊的说不出话来。等到6个月试用期结束的时候，已经可以出差去澳洲和客户的OPs谈笑风生了。2013年的8月，在印度普内，我已经可以用英文给来自世界各国的学生讲课。</p>
<p><img loading="lazy" src="/images/2017/07/twu33-resized.png" type="" alt=""  /></p>
<p>除了更顺畅的和不同文化的人交流，讨论问题之外，可以明显感觉到学习的速度变得更快，更有效率。</p>
<p>我自己实践过的一个比较有效的方法。我每天会花两个小时（早晚各一个小时）看<a href="http://www.australiaplus.com/international/learn-english/">澳洲之音</a>上的视频，我会听写出视频中的每一句话，如果听不清就重复，有的句子可能会重复十遍。听到最后，视频中的每句话我都能听懂，而且能一边听一边写出来。这样坚持了差不多3个月，我基本上就可以听懂客户的需求澄清，开会的时候也可以比较完整的听明白每个人讨论的点。</p>
<p>其实诀窍就是坚持，这3个月中，每天两个小时，我没有一天间断。过了这一关之后，就很容易了，尽量多听多说就好。</p>
<p>另一个提高的方法是翻译书，我更建议你可以更另外一个有经验的同事一起翻译，大家互相监督，也有个照应，比较不容易半途而废。</p>
<h2 id="正确应对犯错">正确应对犯错</h2>
<p>斯坦福大学的<a href="https://en.wikipedia.org/wiki/Carol_Dweck">Carol Dweck</a>教授通过一些实验和后续的研究提出了很有名的心智模型（Mindset）理论，简而言之，她发现不同的人们对待失败这件事有着完全不同的态度：有一类人害怕失败，当失败后会变得不能接受，而且容易否定自身并影响进一步的尝试，Dweck教授称这类人为固定型思维模式（Fixed Mindset）；而另一类人则“喜欢”失败，视失败/犯错为学习的一种方式，他们更关注过程而不是结果，Dweck教授称其为成长型思维模式（Growth Mindset）。</p>
<p><img loading="lazy" src="/images/2017/07/Growth-v-Fixed-resized.png" type="" alt=""  /></p>
<p>Dweck在演讲中提到，通过像成长型思维模式的转变，关注从失败/犯错中学习，人们的潜力可以得到很好的发挥，也更容易获得理想的结果。</p>
<p>很多新人不敢尝试，又不愿意让同事知道自己的不足，这样的态度会导致他更倾向于选择更容易的工作，这样就可以避免暴露自己的不足，久而久之就会形成恶性循环。其实企业对于新人的期望一般都不会很高，对于新人犯错也是有容忍度的，新人要勇于承认自己的不足，勇于尝试新的事物，勇于犯错并从中学习。</p>
<p>承认自己的不足在刚开始是一件很困难的事情，不过再尝试过几次之后，你就会发现其实也没有那么恐怖。你慢慢会喜欢那种不带任何包袱的、全身心聚焦在学习本身上的快乐。</p>
<h2 id="不要被角色限制">不要被角色限制</h2>
<p>都梁在《血色浪漫》里有段描述陕北农民的文字：</p>
<blockquote>
<p>钟跃民惊讶地发现，在如此贫困恶劣的生存状态下，村民们却很少愁眉苦脸，
他们始终很乐观，他们最喜欢谈论的话题是饮食男女。在饮食方面，由于他们没见
过更好的食品，所以坚持认为酸汤饺子和油泼辣子是天下最美味的食品，如果有人
提出世上还有很多更好吃的东西，那大家会一致认为此人太没见过世面，这驴日的
八成是没吃过酸汤饺子，才在这儿胡咧咧.</p>
</blockquote>
<p>就像酸汤饺子并非天下最美味的食品一样，开发也不是世界上最牛逼的工作。任何一个良好的，健康的产品、项目需要不同的角色共同配合，共同努力。如果仅仅将自己局限在程序员这一角色，时间久了未免会有坐井观天的狭隘。</p>
<p><img loading="lazy" src="/images/2015/01/group-resized.png" type="" alt="坐井观天"  /></p>
<p>作为程序员，既可以往上游去探索需求的梳理，用户痛点的分析，业务价值的挖掘，又可以向下游如测试的编写，产品的发布，运维监控。视野开拓了，才有可能对产品有整体的了解，也更容易在程序员这个角色上做的更好。</p>
<p>作为新人，能在自己擅长的方面发挥长处当然很好，但是如果仅仅局限在自己擅长的方面则未免太过单薄。如果你在前端非常有经验，那么除了将这些经验和知识分享给别人之外，你还可以向别的角色学习他们擅长的技能，比如向测试学习自动化，SBE等；向后端学习高性能，高可用服务器的技术，数据库设计及优化，API设计等；向DevOps学习运维技能，自动化<code>provision</code>技能等等。</p>
<p>这些不同的技术不但可以让你的视野更加开阔，也可以为自己以后尝试不同的角色和机会打好基础。以我自己为例，我刚工作的时候是一个Java开发，后来开始做产品的前端开发。换了工作后又跑到Linux下用C写服务，再后来加入ThoughtWorks后，正经职位是开发，不过在项目上还兼职过一段时间QA，在有些项目上当UX不在场的时候还可以做些简单的设计，在技术社区当讲师，还在一些客户现场做过咨询顾问。我自己觉得在不同的角色上切换非常有意思，我自己也很享受整个过程。</p>
<h2 id="展示你的创意">展示你的创意</h2>
<p>将一个创意、复杂概念或者想法简洁而准确的描述出来是一个非常重要的能力。我见过太多的程序员都是沉默寡言，讲东西声音又小，又紧张，即使有很好的想法也难以完整的表述出来。</p>
<p>不过这个能力是可以锻炼的，只需要借助原型的制作就可以了：</p>
<ul>
<li>画图</li>
<li>静态原型</li>
<li>纸上原型</li>
</ul>
<p>俗话说，一图胜千言。你只需要学习一些简单的绘画技巧就可以大大提高自己的表述能力。</p>
<p><img loading="lazy" src="/images/2017/07/sketch-resized.png" type="" alt=""  /></p>
<p>通过用静态页面（HTML/CSS/JS），mock数据等方式，快速的将创意表达出来是程序员的一个优势，你可以用静态数据，数据文件等方式，通过一些简单的代码快速的作出可以做交互的原型，然后通过和用户不断确认的方式来渐进增强，这种做法可以避免太大的浪费，尽早的将客户价值交付。</p>
<p>原型并不局限在草图，可以工作的静态页面，还可以是一个清晰简洁的演讲。基于PPT的原型还可以用来分析目前产品痛点，对比方案的优劣，展示自己的看法等等。</p>
<p>纸上原型是另一种低成本，可供快速交流沟通的原型方式（图片来自我在ThoughtWorks的同事刘海生）：</p>
<p><img loading="lazy" src="/images/2016/09/prototype-resized.png" type="" alt=""  /></p>
<h2 id="手速">手速</h2>
<p>关于程序员是否要求很快的手速是一个颇具争议的话题。支持者认为这属于基本功，每个程序员都应该打字都很快；反对者则认为程序员的价值在于思考并解决问题，追求速度快，那还不如招个打字员。我个人的观点是，好的程序员应该有很快的手速（包括打字的速度，但不局限于此）。</p>
<p>我在ThoughtWorks西安办公室组织过很多次提升手速的工作坊，比如<a href="http://icodeit.org/3-pages-in-3-weeks/">三周三页面</a>，<a href="http://icodeit.org/2016/05/practise-in-programming/">闪电计划</a>等。基本原则就是对一个具体的“作业”，不断的重复练习。</p>
<p>最近带两个新人，我给他们布置了一个简单的作业：</p>
<p><img loading="lazy" src="/images/2017/07/dribbble-invitation-resized.png" type="" alt=""  /></p>
<p>图片来源：<a href="https://dribbble.com/shots/2154223-Day-021-Dribbble-Invitation-Modal">dirbbble.com</a></p>
<p>基本要求是以最快的速度实现这个页面，并有一点微小的交互（比如选择联系人之后的checkbox会显示选中状态，剩余invites的数量减少等）。第一次做他们用了5个多小时（连同搭建环境，安装Node.js，npm包等），第二次用时2个半小时，第三次用时1个半小时，第四次用时50分钟。</p>
<p>对同一个页面的不断练习听起来是在做重复工作，其实可以联系到很多的内容：</p>
<ul>
<li>命令行的熟悉程度</li>
<li>快捷键的使用</li>
<li>搜索引擎的使用</li>
<li>Stackoverflow使用</li>
</ul>
<p>当你真的可以熟极而流的时候，你才有时间来考虑如何优化，比如如何抽取模板工程（这样下次做同样的事情就回快很多），如何精简DOM结构，如何用命令行工具来帮助自己提速等。手速是大前提，没有速度，一切优化都是脑海中的意淫，无法真实落地。</p>
<h2 id="总结">总结</h2>
<p>要成为一个厉害的程序员，首先当然是要有一个好的身体。此外需要培养一个编程之外的爱好，这样可以让你活的像一个正常人（而不是传统的工科书呆子）。程序员是一个需要不断学习，不断充实的职业，在学习的过程中，英文能力可以帮助你学的更快，更有效，另外正确的应对学习过程中必然会犯的错误，并将每次错误都当成学习的机会。</p>
<p>开发只是软件开发流程中的一环，程序员需要拓展自己的视野，和其他角色一起配合才能保证产品的交付。在日常的开发中，程序员还需要快速、准确的将自己的想法和创意表达出来。最后，更快速的完成手头的工作可以让你有更多的时间来思考，来改进那些低效的工作方式。</p>
<h2 id="扩展阅读">扩展阅读</h2>
<ul>
<li>Carol Dweck教授的演讲<a href="http://open.163.com/movie/2015/3/5/B/MAIP2A8KC_MAIPJJK5B.html">《请相信，你可以进步》</a></li>
<li>Paul Graham的<a href="https://book.douban.com/subject/6021440/">黑客与画家</a></li>
<li><a href="https://medium.com/design-story/if-you-can-draw-these-three-shapes-you-can-draw-the-internet-84d601fa9454">如果你能画这三种基础性状，你就可以画一切</a></li>
<li><a href="http://icodeit.org/2017/01/why-top-programmers-hate-gui/">为什么优秀的程序员喜欢命令行</a></li>
<li><a href="http://icodeit.org/2016/05/practise-in-programming/">刻意练习</a></li>
<li><a href="http://icodeit.org/2016/01/for-those-dev-who-doesnt-want-to-be-a-ux-cannot-be-a-good-consulant/">不想当UX的开发不是好咨询师</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>ThoughtWorks洞见在讲什么</title>
      <link>https://icodeit.org/2017/03/whats-the-thoughtworks-insight-talking-about/</link>
      <pubDate>Sun, 12 Mar 2017 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2017/03/whats-the-thoughtworks-insight-talking-about/</guid>
      <description>ThoughtWorks洞见 ThoughtWorks洞见是ThoughtWorks的一个媒体渠道，汇集了来自ThoughtWorks最优秀的经验和思考，并分享给真正对软件有意愿思考和不断改进的人（修改自官方版本）。
截至目前为止，ThoughtWorks洞见已经汇集了50余位作者的300+篇文章（就在刚才，又有一篇更新）。那么这些文章中都在讨论什么样的话题呢？这篇文章将通过一些技术手段，提取出洞见中的关键字，然后采用可视化的方式呈现出来。
数据获取 本来我打算从RSS上读feed，解析出文章的link，再将所有文章爬一遍，最后保存到本地。不过写了几行代码后发现Wordpress(ThoughtWorks洞见目前托管在一个Wordpress上)默认地只输出最新的feed，这对于关键字提取来说数量远远不够。众所周知，语料库越大，效果越好。
既然是洞见本质上来说就是一个静态站点，那么最简单、最暴力的方式就是直接把站点克隆到本地。这一步通过使用wget可以很容易做到：
wget --mirror -p --html-extension --convert-links -e robots=off -P . \ http://insights.thoughtworkers.org/ 默认地，wget会以站点的完整域名为目录名，然后保存整个站点到本地。我大概看了一下，其实不需要所有的目录，只需要一个层次即可，所以这里用find来做一个过滤，然后将文件名写到一个本地文件filepaths中。
find insights.thoughtworkers.org/ -name index.html -depth 2 &amp;gt; filepaths 这个文件的内容是这样的：
insights.thoughtworkers.org/10-common-questions-of-ba/index.html insights.thoughtworkers.org/10-tips-for-good-offshore-ba/index.html insights.thoughtworkers.org/10-ways-improve-your-pairing-experience/index.html insights.thoughtworkers.org/100-years-computer-science/index.html insights.thoughtworkers.org/1000-cars-improve-beijing-transportation/index.html insights.thoughtworkers.org/3d-printing/index.html insights.thoughtworkers.org/4-advices-for-aid/index.html insights.thoughtworkers.org/5-appointments-with-agile-team/index.html insights.thoughtworkers.org/5-ways-exercise-visual-design/index.html insights.thoughtworkers.org/7-step-agenda-effective-retrospective/index.html insights.thoughtworkers.org/a-decade/index.html insights.thoughtworkers.org/about-team-culture/index.html insights.thoughtworkers.org/about-tw-insights/index.html insights.thoughtworkers.org/agile-coach/index.html insights.thoughtworkers.org/agile-communication/index.html insights.thoughtworkers.org/agile-craftman/index.html ... 数据处理 这样我就可以很容易在python脚本中读取各个文件并做处理了。有了文件之后，需要做这样一些事情：
 抽取HTML中的文本信息 将文本分词成列表 计算列表中所有词的TFIDF值 计算每个词出现的频率 将结果持久化到本地  这里需要用到这样一些pyhton库：
 BeautifulSoap 解析HTML文档并抽取文本 jieba 分词 sk-learn 计算单词出现频率 pandas 其他数据处理  def extract_post_content(file): soup = BeautifulSoup(open(file).read(), &amp;#34;html.parser&amp;#34;) return soup.</description>
      <content:encoded><![CDATA[<h2 id="thoughtworks洞见">ThoughtWorks洞见</h2>
<p><a href="http://insights.thoughtworkers.org/">ThoughtWorks洞见</a>是ThoughtWorks的一个媒体渠道，汇集了来自ThoughtWorks最优秀的经验和思考，并分享给真正对软件有意愿思考和不断改进的人（修改自官方版本）。</p>
<p>截至目前为止，ThoughtWorks洞见已经汇集了50余位作者的300+篇文章（就在刚才，又有一篇更新）。那么这些文章中都在讨论什么样的话题呢？这篇文章将通过一些技术手段，提取出洞见中的关键字，然后采用可视化的方式呈现出来。</p>
<h3 id="数据获取">数据获取</h3>
<p>本来我打算从<code>RSS</code>上读feed，解析出文章的<code>link</code>，再将所有文章爬一遍，最后保存到本地。不过写了几行代码后发现<code>Wordpress</code>(ThoughtWorks洞见目前托管在一个Wordpress上)默认地只输出最新的<code>feed</code>，这对于关键字提取来说数量远远不够。众所周知，语料库越大，效果越好。</p>
<p>既然是洞见本质上来说就是一个静态站点，那么最简单、最暴力的方式就是直接把站点克隆到本地。这一步通过使用<code>wget</code>可以很容易做到：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">wget --mirror -p --html-extension --convert-links -e <span class="nv">robots</span><span class="o">=</span>off -P . <span class="se">\
</span><span class="se"></span>http://insights.thoughtworkers.org/
</code></pre></div><p>默认地，<code>wget</code>会以站点的完整域名为目录名，然后保存整个站点到本地。我大概看了一下，其实不需要所有的目录，只需要一个层次即可，所以这里用<code>find</code>来做一个过滤，然后将文件名写到一个本地文件<code>filepaths</code>中。</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">find insights.thoughtworkers.org/ -name index.html -depth <span class="m">2</span> &gt; filepaths
</code></pre></div><p>这个文件的内容是这样的：</p>
<pre><code>insights.thoughtworkers.org/10-common-questions-of-ba/index.html
insights.thoughtworkers.org/10-tips-for-good-offshore-ba/index.html
insights.thoughtworkers.org/10-ways-improve-your-pairing-experience/index.html
insights.thoughtworkers.org/100-years-computer-science/index.html
insights.thoughtworkers.org/1000-cars-improve-beijing-transportation/index.html
insights.thoughtworkers.org/3d-printing/index.html
insights.thoughtworkers.org/4-advices-for-aid/index.html
insights.thoughtworkers.org/5-appointments-with-agile-team/index.html
insights.thoughtworkers.org/5-ways-exercise-visual-design/index.html
insights.thoughtworkers.org/7-step-agenda-effective-retrospective/index.html
insights.thoughtworkers.org/a-decade/index.html
insights.thoughtworkers.org/about-team-culture/index.html
insights.thoughtworkers.org/about-tw-insights/index.html
insights.thoughtworkers.org/agile-coach/index.html
insights.thoughtworkers.org/agile-communication/index.html
insights.thoughtworkers.org/agile-craftman/index.html
...
</code></pre><h3 id="数据处理">数据处理</h3>
<p>这样我就可以很容易在python脚本中读取各个文件并做处理了。有了文件之后，需要做这样一些事情：</p>
<ol>
<li>抽取HTML中的文本信息</li>
<li>将文本分词成列表</li>
<li><del>计算列表中所有词的<a href="https://zh.wikipedia.org/wiki/Tf-idf">TFIDF</a>值</del></li>
<li>计算每个词出现的频率</li>
<li>将结果持久化到本地</li>
</ol>
<p>这里需要用到这样一些pyhton库：</p>
<ol>
<li>BeautifulSoap 解析HTML文档并抽取文本</li>
<li>jieba 分词</li>
<li>sk-learn 计算单词出现频率</li>
<li>pandas 其他数据处理</li>
</ol>
<div class="highlight"><pre class="chroma"><code class="language-py" data-lang="py"><span class="k">def</span> <span class="nf">extract_post_content</span><span class="p">(</span><span class="n">file</span><span class="p">):</span>
    <span class="n">soup</span> <span class="o">=</span> <span class="n">BeautifulSoup</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="n">file</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">(),</span> <span class="s2">&#34;html.parser&#34;</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">soup</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="s1">&#39;div&#39;</span><span class="p">,</span> <span class="n">attrs</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;class&#39;</span><span class="p">:</span> <span class="s1">&#39;entry-content&#39;</span><span class="p">})</span><span class="o">.</span><span class="n">text</span>

<span class="k">def</span> <span class="nf">extract_all_text</span><span class="p">():</span>
    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">&#39;filepaths&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
        <span class="n">content</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">readlines</span><span class="p">()</span>

    <span class="n">file_list</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">content</span><span class="p">]</span>
    <span class="k">return</span> <span class="nb">map</span><span class="p">(</span><span class="n">extract_post_content</span><span class="p">,</span> <span class="n">file_list</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">extract_segments</span><span class="p">(</span><span class="n">data</span><span class="p">):</span>
    <span class="n">seg_list</span> <span class="o">=</span> <span class="n">jieba</span><span class="o">.</span><span class="n">cut</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">cut_all</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">[</span><span class="n">seg</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span> <span class="k">for</span> <span class="n">seg</span> <span class="ow">in</span> <span class="n">seg_list</span> <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">seg</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">]</span>


<span class="k">def</span> <span class="nf">keywords_calc</span><span class="p">():</span>        
    <span class="n">corpus</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34; &#34;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">item</span><span class="p">)</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="nb">map</span><span class="p">(</span><span class="n">extract_segments</span><span class="p">,</span> <span class="n">extract_all_text</span><span class="p">())]</span>

<span class="n">keywords_calc</span><span class="p">()</span>
</code></pre></div><p><code>extract_post_content</code>函数用来打开一篇博客的HTML文件，并提取其中的<code>div.entry-content</code>中的文本内容。<code>extract_all_text</code>函数用来对文件<code>filepaths</code>中的每一行（一篇洞见文章的本地文件路径）都调用一次<code>extract_post_content</code>。而函数<code>extract_segments</code>会使用<code>jieba</code>来对每篇文章进行分词，并生成一个单词组成给的列表。最后，在函数<code>keywords_calc</code>中，通过一个列表推导式来生成语料库。</p>
<p>有了语料库之后，很容易使用<code>sk-learn</code>来进行计算：</p>
<div class="highlight"><pre class="chroma"><code class="language-py" data-lang="py"><span class="k">def</span> <span class="nf">keywords_calc</span><span class="p">():</span>        
    <span class="n">corpus</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34; &#34;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">item</span><span class="p">)</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="nb">map</span><span class="p">(</span><span class="n">extract_segments</span><span class="p">,</span> <span class="n">extract_all_text</span><span class="p">())]</span>
    
    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">&#39;stopwords-utf8.txt&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
        <span class="n">content</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">readlines</span><span class="p">()</span>

    <span class="n">content</span><span class="o">.</span><span class="n">extend</span><span class="p">([</span><span class="s1">&#39;来说&#39;</span><span class="p">,</span> <span class="s1">&#39;事情&#39;</span><span class="p">,</span> <span class="s1">&#39;提供&#39;</span><span class="p">,</span> <span class="s1">&#39;带来&#39;</span><span class="p">,</span> <span class="s1">&#39;发现&#39;</span><span class="p">])</span>
    <span class="n">stopwords</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">&#39;utf-8&#39;</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">content</span><span class="p">]</span>

    <span class="n">vectorizer</span> <span class="o">=</span> <span class="n">CountVectorizer</span><span class="p">(</span><span class="n">stop_words</span><span class="o">=</span><span class="n">stopwords</span><span class="p">)</span>
    <span class="n">fit</span> <span class="o">=</span> <span class="n">vectorizer</span><span class="o">.</span><span class="n">fit_transform</span><span class="p">(</span><span class="n">corpus</span><span class="p">)</span>
</code></pre></div><p>当然，由于处理的是中文，我们需要提供<code>停止词</code>来避免对无意义的词的统计（<code>这个</code>，<code>那个</code>，<code>然后</code>等等基本上每篇都会出现多次的词）。在经过<code>transform</code>之后，我们就得到了一个稀疏矩阵和词汇表，以及对应的tdidf的值，我们使用<code>pandas</code>提供的DataFrame来进行排序和存储即可：</p>
<div class="highlight"><pre class="chroma"><code class="language-py" data-lang="py"><span class="k">def</span> <span class="nf">keywords_calc</span><span class="p">():</span> 
	
	<span class="c1">#...   </span>
    <span class="n">data</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">vectorizer</span><span class="o">.</span><span class="n">get_feature_names</span><span class="p">(),</span> <span class="n">fit</span><span class="o">.</span><span class="n">toarray</span><span class="p">()</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="mi">0</span><span class="p">)))</span>
    <span class="n">top_100</span> <span class="o">=</span> <span class="n">DataFrame</span><span class="p">(</span><span class="n">data</span><span class="o">.</span><span class="n">items</span><span class="p">(),</span> <span class="n">columns</span><span class="o">=</span><span class="p">[</span><span class="s1">&#39;word&#39;</span><span class="p">,</span> <span class="s1">&#39;freq&#39;</span><span class="p">])</span>
        <span class="o">.</span><span class="n">sort_values</span><span class="p">(</span><span class="s1">&#39;freq&#39;</span><span class="p">,</span> <span class="n">ascending</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span><span class="o">.</span><span class="n">head</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
    <span class="n">top_100</span><span class="o">.</span><span class="n">to_csv</span><span class="p">(</span><span class="s1">&#39;top-100-words-most-used-in-tw-insights.csv&#39;</span><span class="p">)</span>
</code></pre></div><p>运行结果如下：</p>
<pre><code>index,word,freq
18761,团队,1922
12479,测试,1851
4226,开发,1291
1910,服务,1288
10531,技术,1248
7081,用户,1145
17517,代码,1078
12712,项目,1062
4957,需求,1049
...
</code></pre><h3 id="可视化">可视化</h3>
<h4 id="单词云">单词云</h4>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">d3</span><span class="p">.</span><span class="nx">csv</span><span class="p">(</span><span class="s1">&#39;top-20-words-in-tw-insight.csv&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">data</span><span class="p">)</span> <span class="p">{</span>
    <span class="nx">data</span><span class="p">.</span><span class="nx">forEach</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span> <span class="p">{</span>
        <span class="nx">d</span><span class="p">.</span><span class="nx">freq</span> <span class="o">=</span> <span class="o">+</span><span class="nx">d</span><span class="p">.</span><span class="nx">freq</span>
    <span class="p">});</span>

    <span class="nx">d3</span><span class="p">.</span><span class="nx">layout</span><span class="p">.</span><span class="nx">cloud</span><span class="p">().</span><span class="nx">size</span><span class="p">([</span><span class="mi">1600</span><span class="p">,</span> <span class="mi">900</span><span class="p">])</span>
        <span class="p">.</span><span class="nx">words</span><span class="p">(</span><span class="nx">data</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">rotate</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">fontSize</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">round</span><span class="p">(</span><span class="nx">d</span><span class="p">.</span><span class="nx">freq</span><span class="o">/</span><span class="mi">10</span><span class="p">);</span> <span class="p">})</span>
        <span class="p">.</span><span class="nx">on</span><span class="p">(</span><span class="s2">&#34;end&#34;</span><span class="p">,</span> <span class="nx">draw</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">start</span><span class="p">();</span>

<span class="p">});</span>
</code></pre></div><p>这里我直接使用了一个第三方的单词云插件<code>d3.layout.cloud</code>，提供一个callback函数<code>draw</code>，当布局结束之后，插件会调用这个回调：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">draw</span><span class="p">(</span><span class="nx">words</span><span class="p">)</span> <span class="p">{</span>
    <span class="nx">d3</span><span class="p">.</span><span class="nx">select</span><span class="p">(</span><span class="s2">&#34;body&#34;</span><span class="p">).</span><span class="nx">append</span><span class="p">(</span><span class="s2">&#34;svg&#34;</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s2">&#34;width&#34;</span><span class="p">,</span> <span class="nx">width</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s2">&#34;height&#34;</span><span class="p">,</span> <span class="nx">height</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s2">&#34;class&#34;</span><span class="p">,</span> <span class="s2">&#34;wordcloud&#34;</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">append</span><span class="p">(</span><span class="s2">&#34;g&#34;</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s2">&#34;transform&#34;</span><span class="p">,</span> <span class="s2">&#34;translate(&#34;</span> <span class="o">+</span> <span class="nx">width</span><span class="o">/</span><span class="mi">2</span> <span class="o">+</span> <span class="s2">&#34;,&#34;</span> <span class="o">+</span> <span class="nx">height</span><span class="o">/</span><span class="mi">2</span> <span class="o">+</span><span class="s2">&#34;)&#34;</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">selectAll</span><span class="p">(</span><span class="s2">&#34;text&#34;</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">data</span><span class="p">(</span><span class="nx">words</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">enter</span><span class="p">().</span><span class="nx">append</span><span class="p">(</span><span class="s2">&#34;text&#34;</span><span class="p">)</span>
        <span class="p">.</span><span class="nx">style</span><span class="p">(</span><span class="s2">&#34;font-size&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">round</span><span class="p">(</span><span class="nx">d</span><span class="p">.</span><span class="nx">freq</span><span class="o">/</span><span class="mi">10</span><span class="p">)</span> <span class="o">+</span> <span class="s2">&#34;px&#34;</span><span class="p">;</span> <span class="p">})</span>
        <span class="p">.</span><span class="nx">style</span><span class="p">(</span><span class="s2">&#34;fill&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="nx">color</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span> <span class="p">})</span>
        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s2">&#34;transform&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span> <span class="p">{</span>
            <span class="k">return</span> <span class="s2">&#34;translate(&#34;</span> <span class="o">+</span> <span class="p">[</span><span class="nx">d</span><span class="p">.</span><span class="nx">x</span><span class="p">,</span> <span class="nx">d</span><span class="p">.</span><span class="nx">y</span><span class="p">]</span> <span class="o">+</span> <span class="s2">&#34;)rotate(&#34;</span> <span class="o">+</span> <span class="nx">d</span><span class="p">.</span><span class="nx">rotate</span> <span class="o">+</span> <span class="s2">&#34;)&#34;</span><span class="p">;</span>
        <span class="p">})</span>
        <span class="p">.</span><span class="nx">text</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="nx">d</span><span class="p">.</span><span class="nx">word</span><span class="p">;</span> <span class="p">});</span>
<span class="p">}</span>
</code></pre></div><p><img loading="lazy" src="/images/2017/03/tw-insights-color-18-resized.png" type="" alt=""  /></p>
<h4 id="背景图制作">背景图制作</h4>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">mkdir -p authors/ <span class="o">&amp;&amp;</span> cp wp-content/authors/* authors/
<span class="nb">cd</span> authors
mogrify -format png *.jpg 
rm *.jpg
</code></pre></div><p>将作者的头像制作成一张9x6的大<code>蒙太奇</code>图：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">montage *.png  -geometry +0+0 -resize 128x128^ -gravity center -crop 128x128+0+0 -tile 9x6 <span class="se">\
</span><span class="se"></span>	tw-insight-authors.png
</code></pre></div><p><img loading="lazy" src="/images/2017/03/tw-insight-authors-resized.png" type="" alt=""  /></p>
<h4 id="后期处理">后期处理</h4>
<p><img loading="lazy" src="/images/2017/03/tw-insights-12-resized.png" type="" alt=""  /></p>
<p>可以看出，ThoughtWorks洞见中最为关键（Top 10）的信息依次是：</p>
<pre><code>团队
测试
开发
服务
技术
用户
代码
项目
需求
工作
</code></pre><p>这个和ThoughtWorks的专业服务公司的属性基本吻合。不过前20里竟然没有诸如<code>敏捷</code>，<code>精益</code>这些原本以为会入围的词。</p>
<h4 id="完善">完善</h4>
<p>基本的图形设计完成之后，再加入一些视觉元素，比如ThoughtWorks的标志性图案（代表开发文化和多样性），以及对应的说明性文字（文字的大小也错落开，和文字云遥相呼应）：</p>
<p><img loading="lazy" src="/images/2017/03/tw-insights-16-resized.png" type="" alt=""  /></p>
<h3 id="资料">资料</h3>
<p>文中使用了比较简单的<code>CountVectorizer</code>做统计，<code>sk-learn</code>还提供了其他的向量化机制。我使用<code>TdidfVectorizer</code>做了一些计算，不过可能由于语料库的尺寸原因，效果比较奇怪，就暂时没有采用这种方式。</p>
<p>不过，使用<code>TDIDF</code>来做关键词抽取在文本处理上也算是必备的技能，这里列一些参考资料，有兴趣的可以进行进一步的探索。</p>
<ol>
<li><a href="https://github.com/abruzzi/tw-insights-viz">完整的代码</a>在此。</li>
<li>阮一峰老师对<a href="http://www.ruanyifeng.com/blog/2013/03/tf-idf.html">TFIDF的解释文章</a></li>
<li>陈皓（左耳朵耗子）对<a href="http://coolshell.cn/articles/8422.html">TFIDF的解释文章</a></li>
</ol>
]]></content:encoded>
    </item>
    
    <item>
      <title>我的2016</title>
      <link>https://icodeit.org/2016/12/my-2016/</link>
      <pubDate>Wed, 28 Dec 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/12/my-2016/</guid>
      <description>大事记 把女儿心心哄睡着之后，我躺在她旁边，听着她平稳的呼吸声，心里充满了幸福和感激。女儿降生的那种感动，是无以伦比的，之前的很多事情变得无所谓起来，这当然是我今年最大的收获。
当然，初为人父，有好多好多东西需要学习，她还在月子里的时候，我整理过一次思维导图：
今年也有一些其他的里程碑：
 骑行了第一个100公里 学会了驾驶（已经行驶了近6000公里） 学会了抱娃，换尿布，给娃洗澡，试水温等等 《轻量级Web应用开发》被翻译成繁体中文版在台湾发售 Hiking到了秦岭最高点（大爷海，海拔3500m）  学习 今年的大部分时间都不在办公室，在客户现场出差有8-9个月。最大的感受是归属感的缺乏，另外就是大部分时候再输出，会导致积累的存货快要被掏空的感觉。很多知识需要花时间来补充上，咨询工作本身有很大一部分是需要咨询师在非咨询项目上做积累，然后再去输出的。
这一点希望在2017年可以做的更好一些：减少一些出差，多在办公室的项目上工作，然后能有更多的时间来积累自己的知识库。
上半年花了一些时间和设计师唐婉莹合写的《在迭代1之前》，后来出差网络比较封闭的时候，就只有唐婉莹在做更新（频率和质量都很高），我自己的开发部分很久没有改动了，算是一个比较遗憾的地方。2017年希望可以完成其中的烂尾部分。
总体来说，2016年很多时间是做咨询工作，内容比较杂乱。我梳理了一下，大致如下：
一些微小的练习 我的第一个React Natvie应用，感谢傅若愚：
闪电计划的页面局部，感谢张小虫：
 Graphviz一个例子： 
闪电计划 7月，和另外两个同事组织了一个系列的活动，这个活动旨在通过一系列的刻意练习，包括但不限于：
 TDD，Tasking，构建，环境自动化 自动化测试（集成测试，UI测试） 项目中的常见场景（多表关联，异常处理，RESTful API设计） 常见静态页面 一些具体而微的端到端Web项目  闪电计划的另一个副作用是找出了一些前端的Kata，可以供后续的前端们做练习用。我已经找张小虫，李彤欣做过了第一次的实验，证明是一个比较合理的方向。在2017年，可以作为新的Workshop进行。
项目经历 元月份经历了一个史上最奇特的咨询项目：Staffing好的3个人中，有两个离职了……。不过还好，通过两个月的微小工作，客户最终还是比较满意的，也很顺利的有了项目的第二期（虽然由于其他原因，第二期只做了一半）。
其他的经历比较平淡：
 在回南天的3月去了一趟广州出差，做了一些前端性能相关的测试。 在最热的7月份去了一趟上海出差，莫名其妙的做了一些前端性能相关的测试，以及React Native的一些预研。 最后在寒冷的12月去了一趟深圳出差，做了一些安全测试（基于OWASP）、依赖关系图（基于Doxygen）等的Spike。  不过总体来看，2016年经历的项目是最多的，而且多样性也很高：
 3个咨询项目 3个交付项目 3个售前  其他 应王欢要求，除了一起吃过几次饭之外，今年跟王欢基本上没有交集。倒是多亏了他的脸，在楼下的来福士和他喝了不少次咖啡。
这是九月份去付莹家的黄河时和同事们的合影，第一次开车走高速去那么远的地方，后座还有一个澳洲的客户。
骑行了一半儿，有一群开着车的同事追了上来，跟我们一起吃了个饭，我们骑车回去，他们则开车/坐车回去了。</description>
      <content:encoded><![CDATA[<h2 id="大事记">大事记</h2>
<p>把女儿心心哄睡着之后，我躺在她旁边，听着她平稳的呼吸声，心里充满了幸福和感激。女儿降生的那种感动，是无以伦比的，之前的很多事情变得无所谓起来，这当然是我今年最大的收获。</p>
<p><img loading="lazy" src="/images/2016/12/xx-2-resized.png" type="" alt="心心"  /></p>
<p>当然，初为人父，有<code>好多好多</code>东西需要学习，她还在月子里的时候，我整理过一次思维导图：</p>
<p><img loading="lazy" src="/images/2016/12/new-born-resized.png" type="" alt="新生儿"  /></p>
<p>今年也有一些其他的里程碑：</p>
<ul>
<li>骑行了第一个100公里</li>
<li>学会了驾驶（已经行驶了近6000公里）</li>
<li>学会了抱娃，换尿布，给娃洗澡，试水温等等</li>
<li><a href="https://book.douban.com/subject/26585461/">《轻量级Web应用开发》</a>被翻译成繁体中文版在台湾发售</li>
<li>Hiking到了秦岭最高点（大爷海，海拔3500m）</li>
</ul>
<p><img loading="lazy" src="/images/2016/12/mybook-resized.png" type="" alt=""  /></p>
<h3 id="学习">学习</h3>
<p>今年的大部分时间都不在办公室，在客户现场出差有8-9个月。最大的感受是归属感的缺乏，另外就是大部分时候再输出，会导致积累的存货快要被掏空的感觉。很多知识需要花时间来补充上，咨询工作本身有很大一部分是需要咨询师在非咨询项目上做积累，然后再去输出的。</p>
<p>这一点希望在2017年可以做的更好一些：减少一些出差，多在办公室的项目上工作，然后能有更多的时间来积累自己的知识库。</p>
<p>上半年花了一些时间和设计师唐婉莹合写的<a href="https://www.gitbook.com/book/juntao/pre-iteration-zero/details">《在迭代1之前》</a>，后来出差网络比较封闭的时候，就只有唐婉莹在做更新（频率和质量都很高），我自己的开发部分很久没有改动了，算是一个比较遗憾的地方。2017年希望可以完成其中的烂尾部分。</p>
<p>总体来说，2016年很多时间是做咨询工作，内容比较杂乱。我梳理了一下，大致如下：</p>
<p><img loading="lazy" src="/images/2016/12/learning-resized.png" type="" alt=""  /></p>
<h4 id="一些微小的练习">一些微小的练习</h4>
<p>我的第一个React Natvie应用，感谢傅若愚：</p>
<p><img loading="lazy" src="/images/2016/12/react-native-resized.png" type="" alt=""  /></p>
<p>闪电计划的页面局部，感谢张小虫：</p>
<p><img loading="lazy" src="/images/2016/12/bookish-detail-resized.png" type="" alt=""  /></p>
<del>
Graphviz一个例子：
<p><img loading="lazy" src="/images/2016/12/graphgiz-demo-resized.png" type="" alt=""  />
</del></p>
<h4 id="闪电计划">闪电计划</h4>
<p>7月，和另外两个同事组织了一个系列的活动，这个活动旨在通过一系列的刻意练习，包括但不限于：</p>
<ul>
<li>TDD，Tasking，构建，环境自动化</li>
<li>自动化测试（集成测试，UI测试）</li>
<li>项目中的常见场景（多表关联，异常处理，RESTful API设计）</li>
<li>常见静态页面</li>
<li>一些具体而微的端到端Web项目</li>
</ul>
<p><img loading="lazy" src="/images/2016/12/lighting-resized.png" type="" alt=""  /></p>
<p>闪电计划的另一个副作用是找出了一些前端的Kata，可以供后续的前端们做练习用。我已经找张小虫，李彤欣做过了第一次的实验，证明是一个比较合理的方向。在2017年，可以作为新的Workshop进行。</p>
<h3 id="项目经历">项目经历</h3>
<p>元月份经历了一个史上最奇特的咨询项目：Staffing好的3个人中，有两个离职了……。不过还好，通过两个月的微小工作，客户最终还是比较满意的，也很顺利的有了项目的第二期（虽然由于其他原因，第二期只做了一半）。</p>
<p>其他的经历比较平淡：</p>
<ul>
<li>在回南天的3月去了一趟广州出差，做了一些前端性能相关的测试。</li>
<li>在最热的7月份去了一趟上海出差，莫名其妙的做了一些前端性能相关的测试，以及<code>React Native</code>的一些预研。</li>
<li>最后在寒冷的12月去了一趟深圳出差，做了一些安全测试（基于<code>OWASP</code>）、依赖关系图（基于<code>Doxygen</code>）等的Spike。</li>
</ul>
<p>不过总体来看，2016年经历的项目是最多的，而且多样性也很高：</p>
<ul>
<li>3个咨询项目</li>
<li>3个交付项目</li>
<li>3个售前</li>
</ul>
<h3 id="其他">其他</h3>
<p>应王欢要求，除了一起吃过几次饭之外，今年跟王欢基本上没有交集。倒是多亏了他的脸，在楼下的来福士和他喝了不少次咖啡。</p>
<p><img loading="lazy" src="/images/2016/12/huanghe-resized.png" type="" alt=""  /></p>
<p>这是九月份去付莹家的黄河时和同事们的合影，第一次开车走高速去那么远的地方，后座还有一个澳洲的客户。</p>
<p><img loading="lazy" src="/images/2016/12/cycling-resized.png" type="" alt=""  /></p>
<p>骑行了一半儿，有一群开着车的同事追了上来，跟我们一起吃了个饭，我们骑车回去，他们则开车/坐车回去了。</p>
<p><img loading="lazy" src="/images/2016/12/reunion-resized.png" type="" alt=""  /></p>
]]></content:encoded>
    </item>
    
    <item>
      <title>敏捷团队里的QA</title>
      <link>https://icodeit.org/2016/09/what-should-qa-do-in-a-agile-team/</link>
      <pubDate>Sat, 24 Sep 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/09/what-should-qa-do-in-a-agile-team/</guid>
      <description>QA的职责 我们先讨论一下传统的瀑布模型下QA是如何工作的，其中最主要的问题是什么；然后作为对比，我们来看看在敏捷团队里QA又是如何工作的，工作重点又是什么；最后，我们详细看一看在新的职责下，QA应该如何做。
瀑布开发模型 即使在今天，在很多企业中，瀑布模型仍然是主流。每一个需求都需要经过分析，设计，开发，测试，上线部署，运维等阶段。虽然一些企业已经在实施敏捷开发，比如项目/产品以迭代的方式运作，也有诸如每日站会，代码检视等敏捷实践，但是如果仔细审视，你会发现其实开发模式骨子里还是瀑布：按照软件组件划分的部门结构（详见康威定律），按照职能划分的团队（开发和测试分属不同部门），过长的反馈周期，永远无法摆脱的集成难题等等。
随着软件变得越来越复杂，团队里没有任何一个人可以说出系统是如何运作的，也不知道最终用户是谁，以及最终用户会以何种方式来使用最终的软件。
更糟糕的是，按照职能划分的团队在物理上都是隔离的，比如独立的测试部门，独立的运维部门，整日忙碌而难以预约到档期的业务人员，当然还有经常疲于交付，无处吐槽的苦逼开发。由于这些隔离，信息的反馈周期会非常长，一个本来很容易修复的缺陷可能在4周之后才可能被另一个部门的测试发现，然后通过复杂的工作流（比如某种形式的缺陷追踪系统）流到开发那里，而开发可能还在拼命的完成早就应该交付的功能，从而形成恶性循环。
瀑布模式中的QA 在这样的环境中，QA们能做的事情非常有限。在需求开始时会他们参加需求澄清的会议，制定一些测试计划，然后进行测试用例的设计。有的企业会用诸如Excel之类的工具来记录这些用例。这些写在Excel里的，死的用例用处非常有限。而最大的问题在于：它们无法自动化执行。另外，在实际软件开发中，需求总是会经常发生变化，需求的优先级也会有调整，然后这些记录在Excel中的死的用例会很快过期，变得无人问津。
除此之外，QA中的有些成员会使用工具来录制一些UI测试的场景，然后在每个新版本出来之后进行回放即可。然而，当UI发生一点变化之后，这些自动化的用例就会失效：比如HTML片段中元素位置的调整，JavaScript的异步调用超时等等。
显然，这种单纯以黑盒的形式来检查功能点的测试方式是不工作的，要真正有效的提升软件质量，仅仅通过事后检查是远远不够的，软件的质量也应该内建于软件之中。QA的工作也应该是一个贯穿软件生命周期的活动，从商业想法，到真实上线，这其中的所有环节，都应该有QA的参与。
系统思考 如果不从一个系统的角度来思考软件质量，就无法真正构建出健壮的、让业务和团队都有信心的软件系统。质量从来都不只是QA的职责，而是整个团队的职责。
关于软件质量，一个根深蒂固的误解是：缺陷在开发过程中被引入，然后在测试阶段被发现，最后在QA和开发的来来回回的撕扯中被解决（或者数量被大规模降低），最后在生产环境中，就只会有很少的，优先级很低的缺陷。
然而事实上，很多需求就没有仔细分析，业务价值不很确定，验收条件模糊，流入开发后又会引入一些代码级别的错误，以及业务规则上的缺陷，测试阶段会漏掉一些功能点，上线之后更是问题百出（网络故障，缓存失效，黑客攻击，操作系统补丁，甚至内存溢出，log文件将磁盘写满等等）。
在一个敏捷团队中，每个个人都应该对质量负责，而QA则以自己的丰富经验和独特视角来发掘系统中可能的质量隐患，并帮助团队将这些隐患消除。
我在ThoughtWorks的同事Anand Bagmar在他的演讲What is Agile testing- How does automation help?中详细讨论过这部分内容。
QA到底应该干什么？ 本质上来说，任何软件项目的目标都应该是：更快地将高质量的软件从想法变成产品。
将这个大目标细分一下，会得到这样几个子项，即企业需要：
 更多的商业回报（发掘业务价值） 更快的上线时间（做最简单，直接的版本） 更好的软件质量（质量内嵌） 更少的资源投入（减少浪费）  其实就是传说中的多、快、好、省。如果说这是每一个软件项目的目标的话，那么团队里的每一个个人都应该向着这个目标而努力，任何其他形式的工作都可以归类为浪费。用Excel记录那些经常会失效，而且无法自动执行的测试用例是浪费，会因为页面布局变化而大面积失效的UI测试也是浪费，一个容易修复的缺陷要等到数周之后才被发现也是浪费。
在这个大前提下，我们再来思考QA在团队里应该做什么以及怎么做。
QA的职责 Lisa Crispin在《敏捷软件测试》中提到过一个很著名的模型：敏捷测试四象限。这个模型是QA制定测试策略时的一个重要参考：
如果按照纵向划分的话，图中的活动，越向上越面向业务；越向下越面向技术。横向划分的话，往左是支撑团队；往右是评价产品。
其实简化一下，QA在团队里的工作，可以分为两大类：
 确保我们在正确的交付产品 确保我们交付了正确的产品  根据这个四象限的划分，大部分团队可能都会从Q2起步：QA会和BA，甚至UX一起，从需求分析入手，进行需求分析，业务场景梳理，这时候没有具体的可以被测试的软件代码。不过这并不妨碍测试活动，比如一些纸上原型的设计（感谢刘海生供图）：
通过这一阶段之后，我们已经有了用户故事，这时候QA需要和开发一起编写用户故事的自动化验收测试。当开发交付一部分功能之后，QA就可以做常规的用户故事测试，几个迭代之后，QA开始进行跨功能需求测试和探索性测试等。根据探索性测试的结果，QA可能会调整测试策略，调整测试优先级，完善测试用例等等。
根据项目的不同，团队可以从不同的象限开始测试策略的制定。事实上，Q1-Q4仅仅是一个编号，与时间、阶段并无关系，Lisa Crispin还专门撰文解释过。
关于QA如何在软件分析的上游就介入，然后通过BDD的方式与业务分析师一起产出软件的各种规格描述，并通过实例的方式来帮助整个团队对需求的理解，ThoughtWorks的林冰玉有一篇文章很好的介绍了BDD的正确做法。如果将QA的外延扩展到在线的生产环境，制定合理的测量指标，调整测试策略，强烈推荐林冰玉写的另一篇文章产品环境中的QA。
其他职责 事实上，软件生命周期中有很多的活动，有很多处于灰色地段。既可以说是应该开发做，又可以说应该QA做，甚至可以推给其他角色（比如OPs）。不过我们知道，一旦涉及角色，人们就再也不会按照全局优化的思路来应对问题了。这种灰色的活动包括：
 持续集成的搭建 测试环境的创建于维护 UAT上的数据准备 代码中的测试代码的维护 测试代码的重构  在团队实践中，这些活动我们通常会让QA和开发或者OPs同事一起结对来完成。一方面避免知识孤岛的形成，另一方面在跨角色的工作中，也可以激发出更多不同的思路。
万能的QA？ 虽然在这些活动中，QA都会参与，但是并不是说团队里只要有一个QA就可以了。QA在参与这些活动时，侧重点还是有很大不同的。
比如需求分析阶段，如果有QA的加入，一些从QA角度可以发现的有明显缺陷的场景，则可以在分析阶段就得到很好的处理。另一方面，尽早介入可以设计出更合理的测试计划（比如哪些功能的优先级比较高，用户更会频繁使用，那么对应的测试比重也会更高）。在Story分析与书写阶段，QA可以帮助写出更加合理的验收条件，既满足业务需求，又可以很好的指导开发。
在和开发一起编写澄清需求时，主要是编写自动化验收测试，而不是实际编写业务逻辑的实现（虽然QA应该参与Code Reivew环节，学习并分享自己的观点）；甚至在上线运维阶段，QA还需要和OPs一起来设计用户数据的采集指标（比如用户访问的关键路径，浏览器版本，地区的区分等），从而制定出新的测试策略。
扩展阅读  What is Agile testing - How does automation help?</description>
      <content:encoded><![CDATA[<h2 id="qa的职责">QA的职责</h2>
<p>我们先讨论一下传统的瀑布模型下QA是如何工作的，其中最主要的问题是什么；然后作为对比，我们来看看在敏捷团队里QA又是如何工作的，工作重点又是什么；最后，我们详细看一看在新的职责下，QA应该如何做。</p>
<h3 id="瀑布开发模型">瀑布开发模型</h3>
<p>即使在今天，在很多企业中，瀑布模型仍然是主流。每一个需求都需要经过分析，设计，开发，测试，上线部署，运维等阶段。虽然一些企业已经在实施<code>敏捷开发</code>，比如项目/产品以迭代的方式运作，也有诸如每日站会，代码检视等敏捷实践，但是如果仔细审视，你会发现其实<em>开发模式</em>骨子里还是瀑布：按照软件组件划分的部门结构（详见<a href="https://en.wikipedia.org/wiki/Conway%27s_law">康威定律</a>），按照职能划分的团队（开发和测试分属不同部门），过长的反馈周期，永远无法摆脱的集成难题等等。</p>
<p>随着软件变得越来越复杂，团队里没有任何一个人可以说出系统是如何运作的，也不知道最终用户是谁，以及最终用户会以何种方式来使用最终的软件。</p>
<p>更糟糕的是，按照职能划分的团队在物理上都是隔离的，比如独立的测试部门，独立的运维部门，整日忙碌而难以预约到档期的业务人员，当然还有经常疲于交付，无处吐槽的<em>苦逼</em>开发。由于这些隔离，信息的反馈周期会非常长，一个本来很容易修复的缺陷可能在4周之后才可能被另一个部门的测试发现，然后通过复杂的工作流（比如某种形式的缺陷追踪系统）流到开发那里，而开发可能还在拼命的完成早就应该交付的功能，从而形成恶性循环。</p>
<h3 id="瀑布模式中的qa">瀑布模式中的QA</h3>
<p>在这样的环境中，QA们能做的事情非常有限。在需求开始时会他们参加需求澄清的会议，制定一些<code>测试计划</code>，然后进行测试用例的设计。有的企业会用诸如Excel之类的工具来记录这些用例。这些写在Excel里的，<code>死</code>的用例用处非常有限。而最大的问题在于：它们无法<code>自动化执行</code>。另外，在实际软件开发中，需求总是会经常发生变化，需求的优先级也会有调整，然后这些记录在Excel中的<code>死</code>的用例会很快过期，变得无人问津。</p>
<p>除此之外，QA中的有些成员会使用工具来录制一些UI测试的场景，然后在每个新版本出来之后进行回放即可。然而，当UI发生一点变化之后，这些自动化的用例就会失效：比如<code>HTML</code>片段中元素位置的调整，<code>JavaScript</code>的异步调用超时等等。</p>
<p>显然，这种单纯以黑盒的形式来<strong>检查功能点</strong>的测试方式是不工作的，要真正有效的提升软件质量，仅仅通过<strong>事后检查</strong>是远远不够的，软件的质量也应该内建于软件之中。QA的工作也应该是一个贯穿软件生命周期的活动，从商业想法，到真实上线，这其中的所有环节，都应该有QA的参与。</p>
<h3 id="系统思考">系统思考</h3>
<p>如果不从一个系统的角度来思考软件质量，就无法真正构建出健壮的、让业务和团队都有信心的软件系统。<em><strong>质量从来都不只是QA的职责，而是整个团队的职责。</strong></em></p>
<p>关于软件质量，一个根深蒂固的误解是：缺陷在开发过程中被引入，然后在测试阶段被发现，最后在QA和开发的来来回回的撕扯中被解决（或者数量被大规模降低），最后在生产环境中，就只会有很少的，优先级很低的缺陷。</p>
<p>然而事实上，很多需求就没有仔细分析，业务价值不很确定，验收条件模糊，流入开发后又会引入一些代码级别的错误，以及业务规则上的缺陷，测试阶段会漏掉一些功能点，上线之后更是问题百出（网络故障，缓存失效，黑客攻击，操作系统补丁，甚至内存溢出，log文件将磁盘写满等等）。</p>
<p>在一个敏捷团队中，<strong>每个个人都应该对质量负责</strong>，而QA则以自己的丰富经验和独特视角来发掘系统中可能的质量隐患，并帮助团队将这些隐患消除。</p>
<p><img loading="lazy" src="/images/2016/09/circle-resized.png" type="" alt="测试职责"  /></p>
<p>我在ThoughtWorks的同事<code>Anand Bagmar</code>在他的演讲<a href="http://www.slideshare.net/abagmar/what-is-agile-testing-how-does-automation-help">What is Agile testing- How does automation help?</a>中详细讨论过这部分内容。</p>
<h3 id="qa到底应该干什么">QA到底应该干什么？</h3>
<p>本质上来说，任何软件项目的目标都应该是：<strong>更快地将<code>高质量</code>的软件从想法变成产品</strong>。</p>
<p>将这个大目标细分一下，会得到这样几个子项，即企业需要：</p>
<ul>
<li>更多的商业回报（发掘业务价值）</li>
<li>更快的上线时间（做最简单，直接的版本）</li>
<li>更好的软件质量（质量内嵌）</li>
<li>更少的资源投入（减少浪费）</li>
</ul>
<p>其实就是传说中的<strong>多、快、好、省</strong>。如果说这是每一个软件项目的目标的话，那么团队里的每一个个人都应该向着这个目标而努力，任何其他形式的工作都可以归类为<code>浪费</code>。用Excel记录那些经常会失效，而且无法自动执行的测试用例是浪费，会因为页面布局变化而大面积失效的UI测试也是浪费，一个容易修复的缺陷要等到数周之后才被发现也是浪费。</p>
<p>在这个大前提下，我们再来思考QA在团队里应该做什么以及怎么做。</p>
<h3 id="qa的职责-1">QA的职责</h3>
<p>Lisa Crispin在<a href="https://book.douban.com/subject/5338399/">《敏捷软件测试》</a>中提到过一个很著名的模型：敏捷测试四象限。这个模型是QA制定测试策略时的一个重要参考：</p>
<p><img loading="lazy" src="/images/2016/09/agile-testing-quadrants.png" type="" alt="敏捷软件测试"  /></p>
<p>如果按照纵向划分的话，图中的活动，越向上越面向业务；越向下越面向技术。横向划分的话，往左是支撑团队；往右是评价产品。</p>
<p>其实简化一下，QA在团队里的工作，可以分为两大类：</p>
<ul>
<li>确保我们在<code>正确的</code>交付产品</li>
<li>确保我们交付了<code>正确的</code>产品</li>
</ul>
<p>根据这个四象限的划分，大部分团队可能都会从Q2起步：QA会和BA，甚至UX一起，从需求分析入手，进行需求分析，业务场景梳理，这时候没有具体的可以被测试的软件代码。不过这并不妨碍<strong>测试</strong>活动，比如一些纸上原型的设计（感谢刘海生供图）：</p>
<p><img loading="lazy" src="/images/2016/09/prototype-resized.png" type="" alt=""  /></p>
<p>通过这一阶段之后，我们已经有了用户故事，这时候QA需要和开发一起编写用户故事的自动化验收测试。当开发交付一部分功能之后，QA就可以做常规的用户故事测试，几个迭代之后，QA开始进行跨功能需求测试和探索性测试等。根据探索性测试的结果，QA可能会调整测试策略，调整测试优先级，完善测试用例等等。</p>
<p>根据项目的不同，团队可以从不同的象限开始测试策略的制定。事实上，Q1-Q4仅仅是一个编号，与时间、阶段并无关系，Lisa Crispin还专门<a href="http://lisacrispin.com/2011/11/08/using-the-agile-testing-quadrants/">撰文解释</a>过。</p>
<p>关于QA如何在软件分析的上游就介入，然后通过BDD的方式与业务分析师一起产出软件的各种规格描述，并通过实例的方式来帮助整个团队对需求的理解，ThoughtWorks的林冰玉有一篇文章很好的介绍了<a href="http://insights.thoughtworkers.org/when-we-talk-about-bdd/">BDD的正确做法</a>。如果将QA的外延扩展到在线的生产环境，制定合理的测量指标，调整测试策略，强烈推荐林冰玉写的另一篇文章<a href="http://www.jianshu.com/p/20b454a88bdb">产品环境中的QA</a>。</p>
<h4 id="其他职责">其他职责</h4>
<p>事实上，软件生命周期中有很多的活动，有很多处于<code>灰色</code>地段。既可以说是应该开发做，又可以说应该QA做，甚至可以推给其他角色（比如OPs）。不过我们知道，一旦涉及角色，人们就再也不会按照<code>全局优化</code>的思路来应对问题了。这种<code>灰色</code>的活动包括：</p>
<ul>
<li>持续集成的搭建</li>
<li>测试环境的创建于维护</li>
<li>UAT上的数据准备</li>
<li>代码中的测试代码的维护</li>
<li>测试代码的重构</li>
</ul>
<p>在团队实践中，这些活动我们通常会让QA和开发或者OPs同事一起结对来完成。一方面避免知识孤岛的形成，另一方面在跨角色的工作中，也可以激发出更多不同的思路。</p>
<h3 id="万能的qa">万能的QA？</h3>
<p>虽然在这些活动中，QA都会参与，但是并不是说团队里只要有一个QA就可以了。QA在参与这些活动时，侧重点还是有很大不同的。</p>
<p>比如需求分析阶段，如果有QA的加入，一些从QA角度可以发现的有明显缺陷的场景，则可以在分析阶段就得到很好的处理。另一方面，尽早介入可以设计出更合理的测试计划（比如哪些功能的优先级比较高，用户更会频繁使用，那么对应的测试比重也会更高）。在Story分析与书写阶段，QA可以帮助写出更加合理的验收条件，既满足业务需求，又可以很好的指导开发。</p>
<p>在和开发一起编写澄清需求时，主要是编写自动化验收测试，而不是实际编写业务逻辑的实现（虽然QA应该参与<code>Code Reivew</code>环节，学习并分享自己的观点）；甚至在上线运维阶段，QA还需要和OPs一起来设计用户数据的采集指标（比如用户访问的关键路径，浏览器版本，地区的区分等），从而制定出新的测试策略。</p>
<h3 id="扩展阅读">扩展阅读</h3>
<ul>
<li><a href="http://www.slideshare.net/abagmar/what-is-agile-testing-how-does-automation-help">What is Agile testing - How does automation help?</a></li>
<li><a href="http://insights.thoughtworkers.org/agile-showcase-se7en/">敏捷实践Showcase的七宗罪</a></li>
<li><a href="http://www.jianshu.com/p/20b454a88bdb">产品环境下的QA</a></li>
<li><a href="https://book.douban.com/subject/5338399/">《敏捷软件测试》</a></li>
</ul>
<p>P.S. 感谢林冰玉对本文的<code>Review</code>和指导。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>如何设计一个培训</title>
      <link>https://icodeit.org/2016/09/how-to-design-a-training/</link>
      <pubDate>Sat, 10 Sep 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/09/how-to-design-a-training/</guid>
      <description>培训元模式 最近在帮客户设计一个微服务进阶版培训的材料，整理的过程中我意识到这类事情我已经做过好多次了。比如在ThoughtWorks的P2能力建设项目，3周3页面工作坊等等，我觉得应该将设计课程/设计培训中的模式、原则和实践都提取一下，形成一个元模式（即关于培训的培训）。
一个培训中的活动，按照时间顺序可以分为三个步骤：
 设计培训内容 培训前期准备 培训中的一些实践  设计培训内容 根据经验，只有那些正好处于瓶颈阶段，需要别人给予一些具体指导的人，培训是最有效的。比如我最近在学习iOS开发，那么用Swift开发一个Todo List应用就特别合适，而另一个基于Objective-C的自动化测试则对我来说一点用也没有（即使这个可能更高级，讲师更牛）。
在任何一个培训可能的设计之前，首先需要回答几个问题：
 培训目的是什么？ 参与者对主题的了解程度如何？ 参与者的组成比例（比如junior占比，senior占比等） 结果如何检验？  一个例子 例子是人类的好朋友，这里我们来看一个例子：
 客户要为负责开发的同事做一次培训，培训的目的是要帮助他们建立微服务架构下的常见实践的知识框架。从结果的长期效果来看，这次培训要能指导实际的开发工作。参与者对微服务的一些概念有初步了解，也做过小的练习，但是诸如如何划分服务边界，如何拆分微服务等，都不了解，也比较迫切的想要了解。
 根据这个上下文，客户希望在培训中可以传递这样一些内容：
 如何拆分微服务 常见的微服务设计原则 拆分微服务的时机 如何做微服务的测试  为了确保信息传递的准确性，我问了一遍上边都提到的列表，并且得到了答案：
 听众是开发经验相对丰富的开发（3-5年） 学习拆分为了将大的应用拆分，以方便维护 自动化测试能力和意识都较为薄弱 听众自己的期望是可以有一些切实可以指导实际开发的收获  在有了这些输入的情况下，我做出了这样一些调整：
 不专门讲拆分微服务 主要精力讲DDD（Domain Driven Design） 设计迭代式的，逐步变得复杂的场景来练习DDD 讲解和练习自动化测试（Consumer Driven Contract） Session+Workshop+讨论的形式  看了这个计划之后，客户开始觉得挺困惑，说这个怎么跟我们梳理的课程诉求不一致？对于这个疑惑，我的建议是这样的：
 之前的例子不能落地（找不到足够复杂的，又适合在培训中拆分的场景） 微服务的核心不是基础设施，而是设计原则，或者说如何在开发中找出边界 有了DDD的指导，划分本身并非难事儿 自动化测试（集成测试和契约测试）的能力和认识必须建立  然后我把整理好的课件，实例分解，课程安排给客户讲了一遍之后，他觉得很满意。客户自己也是懂技术的，在分析了现状之后，后来又专门要求给部门内做一些DDD培训（而不是微服务本身）。
培训方式 同样，方式上也需要一些问题的解答才能有效进行：
 培训总时长 更偏重练习还是偏重讲解（工作坊还是Session，以及各自的占比） 参与者如何投入（比如是工作时间，还是晚上等）  根据经验来看，不论是TWU还是对客户的培训，工作坊和Session结合的方式效果最好。 Workshop至少需要包含这样几部分：
 明确要做的练习（多长时间，达到什么目的等） Showcase（参与感，如果有多轮的话，要保证每个人都有Show的机会，而不是每次同一个人） 讨论环节（点评，这个时机可以做一些小结，将要传递的信息润物细无声的传递出去）  应该避免的做法是:</description>
      <content:encoded><![CDATA[<h2 id="培训元模式">培训元模式</h2>
<p>最近在帮客户设计一个<code>微服务进阶版培训</code>的材料，整理的过程中我意识到这类事情我已经做过好多次了。比如在ThoughtWorks的<code>P2能力建设</code>项目，<a href="http://icodeit.org/3p3w/">3周3页面</a>工作坊等等，我觉得应该将<code>设计课程/设计培训</code>中的模式、原则和实践都提取一下，形成一个元模式（即关于培训的培训）。</p>
<p>一个培训中的活动，按照时间顺序可以分为三个步骤：</p>
<ol>
<li>设计培训内容</li>
<li>培训前期准备</li>
<li>培训中的一些实践</li>
</ol>
<h3 id="设计培训内容">设计培训内容</h3>
<p>根据经验，只有那些正好处于瓶颈阶段，需要别人给予一些具体指导的人，培训是最有效的。比如我最近在学习iOS开发，那么<code>用Swift开发一个Todo List应用</code>就特别合适，而另一个<code>基于Objective-C的自动化测试</code>则对我来说一点用也没有（即使这个可能更高级，讲师更牛）。</p>
<p>在任何一个培训可能的设计之前，首先需要回答几个问题：</p>
<ol>
<li>培训目的是什么？</li>
<li>参与者对主题的了解程度如何？</li>
<li>参与者的组成比例（比如junior占比，senior占比等）</li>
<li>结果如何检验？</li>
</ol>
<h4 id="一个例子">一个例子</h4>
<p>例子是人类的好朋友，这里我们来看一个例子：</p>
<blockquote>
<p>客户要为负责开发的同事做一次培训，培训的目的是要帮助他们建立<code>微服务架构</code>下的常见实践的知识框架。从结果的长期效果来看，这次培训要能指导实际的开发工作。参与者对<code>微服务</code>的一些概念有初步了解，也做过小的练习，但是诸如如何划分服务边界，如何拆分微服务等，都不了解，也比较迫切的想要了解。</p>
</blockquote>
<p>根据这个上下文，客户希望在培训中可以传递这样一些内容：</p>
<ul>
<li>如何拆分微服务</li>
<li>常见的微服务设计原则</li>
<li>拆分微服务的时机</li>
<li>如何做微服务的测试</li>
</ul>
<p>为了确保信息传递的准确性，我问了一遍上边都提到的列表，并且得到了答案：</p>
<ul>
<li>听众是开发经验相对丰富的开发（3-5年）</li>
<li>学习拆分为了将大的应用拆分，以方便维护</li>
<li>自动化测试能力和意识都较为薄弱</li>
<li>听众自己的期望是可以有一些切实可以指导实际开发的收获</li>
</ul>
<p>在有了这些输入的情况下，我做出了这样一些调整：</p>
<ul>
<li>不专门讲拆分微服务</li>
<li>主要精力讲<a href="https://github.com/abruzzi/jigsaw-ddd">DDD</a>（Domain Driven Design）</li>
<li>设计迭代式的，逐步变得复杂的场景来练习DDD</li>
<li>讲解和练习<a href="https://github.com/abruzzi/cdc-demo">自动化测试</a>（Consumer Driven Contract）</li>
<li>Session+Workshop+讨论的形式</li>
</ul>
<p>看了这个计划之后，客户开始觉得挺困惑，说这个怎么跟我们梳理的课程诉求不一致？对于这个疑惑，我的建议是这样的：</p>
<ul>
<li>之前的例子不能落地（找不到足够复杂的，又适合在培训中拆分的场景）</li>
<li>微服务的核心不是基础设施，而是设计原则，或者说如何在开发中找出边界</li>
<li>有了DDD的指导，划分本身并非难事儿</li>
<li>自动化测试（集成测试和契约测试）的能力和认识必须建立</li>
</ul>
<p>然后我把整理好的课件，实例分解，课程安排给客户讲了一遍之后，他觉得很满意。客户自己也是懂技术的，在分析了现状之后，后来又专门要求给部门内做一些<code>DDD</code>培训（而不是微服务本身）。</p>
<h3 id="培训方式">培训方式</h3>
<p>同样，方式上也需要一些问题的解答才能有效进行：</p>
<ol>
<li>培训总时长</li>
<li>更偏重练习还是偏重讲解（工作坊还是Session，以及各自的占比）</li>
<li>参与者如何投入（比如是工作时间，还是晚上等）</li>
</ol>
<p>根据经验来看，不论是TWU还是对<code>客户</code>的培训，工作坊和Session结合的方式效果最好。
Workshop至少需要包含这样几部分：</p>
<ul>
<li>明确要做的练习（多长时间，达到什么目的等）</li>
<li>Showcase（参与感，如果有多轮的话，要保证每个人都有Show的机会，而不是每次同一个人）</li>
<li>讨论环节（点评，这个时机可以做一些小结，将要传递的信息润物细无声的传递出去）</li>
</ul>
<p><img loading="lazy" src="/images/2016/09/workshop-resized.png" type="" alt="workshop"  /></p>
<p>应该避免的做法是:</p>
<ul>
<li>一个无法完成的任务</li>
<li>过长的时间</li>
<li>没有讨论，没有点评（特别是在中国文化中，Trainer有指出对错的<code>义务</code>）</li>
</ul>
<p>而<code>Session</code>则简单一些，交互比较少，需要讲师之前做足功课</p>
<ul>
<li>有清晰的Agenda（时长，要传递的大致内容）</li>
<li>如果是讲方法论（DDD，BDD等等），最好结合实践</li>
<li>不要讲代码（没有人能看清你的编辑器，也没有人有耐心看超过1行的代码）</li>
<li>一次不要传递太多信息（只讲三点）</li>
</ul>
<p>两者穿插起来，可以收到很好的效果，既不至于让人觉得没有内容，也不会感觉只说不练。</p>
<h4 id="预演dry-run">预演（Dry Run）</h4>
<p>在进行实际的实施之前，可以从参与者中找出一些典型的人进行交流，<code>dry run</code>一两次。不过交流也需要平衡一些事实：</p>
<ol>
<li>侧重点（做对的事情），比如从设计的层面来讲，DDD，重构等方法的掌握比服务的可用性要重要很多</li>
<li>参与者想要听的和主题的相关性（比如培训目的是Story拆分，那么测试驱动开发的需求就要果断放弃）</li>
</ol>
<p>持续建立关注点，引导发散，归纳问题，归类并给出见解和可能的方案。</p>
<h4 id="如何回答问题">如何回答问题</h4>
<p>有两种教学方式：苏格拉底式和填鸭式。苏格拉底式讲究只问不答，通过讲师不断提问的方式让学员自己思考，琢磨，并期望领悟；填鸭式则恰恰相反，假设学员没有任何能动性，讲师纯粹将自己知道的全部告诉学员。</p>
<p>这其实两者在时间中都不合适。有一个度可以把握的是：</p>
<blockquote>
<p>善待问者如撞钟，叩之以小者则小鸣，叩之以大者则大鸣，待其从容，然后尽其声。</p>
</blockquote>
<p>即根据提问的深度来反馈，比如<code>JavaScript</code>培训，学生问如何声明一个数组，讲师讲词法作用域，则费劲而没有效果。经过一段时间的练习和积累之后，学生会问出更深入的问题，这时候再逐步提高答案的深度。</p>
<h3 id="实践">实践</h3>
<h4 id="energize">Energize</h4>
<p>如果培训在白天的话，在午饭后，人们自然会感到困倦，这时候需要一些<code>提神</code>的小游戏帮助人们清醒。适度的紧张（比如简单的7Up游戏）或者肢体动作（做几个广播体操的动作）都会帮助人们振奋精神。</p>
<ul>
<li>围成一个圈的丢球自我介绍</li>
<li>A和B向对方互相介绍自己，然后A反过来向整个Group介绍B，B向整个Group介绍A</li>
<li>7Up</li>
<li>丢空气球</li>
</ul>
<h4 id="工作坊基本准则">工作坊基本准则</h4>
<ol>
<li>按时参加</li>
<li>保持One convensition</li>
<li>手机静音</li>
</ol>
<h4 id="分组进行">分组进行</h4>
<p>分组讨论是一个很好的实践，既可以避免<code>只说不练</code>的现象，又可以让参与者有充分的参与感，还可以让培训的时间长度更灵活，更容易控制。</p>
<p>分组可以用报数的方法，通常人们习惯和自己熟悉的人坐在一起。这会促进他们交头接耳的几率，分组时可以通过报数的方式，比如目标是分为3组，就依次报数1、2、3，然后所有报1的人为1组，报2的人为2组，以此类推。</p>
<p>一个我自己常用的伎俩是自由调整时间。比如在一个练习开始前，你告诉参与者他们有10分钟来完成一个Task，然后在5分钟后，你发现大家都基本已经做完了，这时候可以直接说：时间到！（相信我，没有人真正看表的，他们通常会被手头的任务搞得焦头烂额）。反过来，你可以说：再延长5分钟！以督促那些比较慢的小组动作更快一些，而事实上他们还没有用完限定的10分钟。</p>
<p><img loading="lazy" src="/images/2016/09/grouping-resized.png" type="" alt="grouping"  /></p>
<h4 id="parking-lot">Parking lot</h4>
<p>培训当然需要参与者和trainer的积极互动，但是有时候参与者提出的问题不太适合在课堂上展开：</p>
<ul>
<li>与培训主题关联并不太大</li>
<li>比较个例的问题</li>
<li>争议较大，难以在短时间内讨论清楚的</li>
</ul>
<p>这些问题可以记录下来，在正式课程时间结束后单点讨论，或者作为下一次备课的关键点，加入到课件中。</p>
<h4 id="retro">Retro</h4>
<p>和我们倡导的一切活动一样，培训也需要有始有终。我们需要收集参与者的反馈，包括positive的和constructive的，这样经过几轮迭代之后，培训会成熟而具有一定的可复制性。</p>
<p>可以分成三类：<code>做得好的/有待提高的/一些疑问/建议</code></p>
<p>将问题分组讨论之后，分为三组，然后讨论出一些解决方法。</p>
<p><img loading="lazy" src="/images/2016/09/retro-resized.png" type="" alt="retro"  /></p>
<h4 id="其他">其他</h4>
<ul>
<li>二维码+金数据表单</li>
<li>白板+白板笔</li>
<li>Flipchart</li>
</ul>
<h3 id="总结">总结</h3>
]]></content:encoded>
    </item>
    
    <item>
      <title>你需要的编程练习</title>
      <link>https://icodeit.org/2016/05/practise-in-programming/</link>
      <pubDate>Thu, 26 May 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/05/practise-in-programming/</guid>
      <description>高效幻象 通过对自己的行为观察，我发现在很多时候，我以为我掌握了的知识和技能其实并不牢靠。我引以为豪的高效其实犹如一个彩色的肥皂泡，轻轻一碰就会破碎，散落一地。
你可能只是精通搜索 我们现在所处的时代，信息爆炸，每个人每天都会接触，阅读很多的信息，快速消费，快速遗忘。那种每天早上起来如同皇帝批阅奏折的、虚假的误以为掌握知识的错觉，驱动我们进入一个恶性循环。
即使在我们真的打算解决问题，进行主动学习时，更多的也只是在熟练使用搜索引擎而已（在一个领域待久了，你所使用的关键字准确度自然要比新人高一些，仅此而已）。精通了高效率搜索之后，你会产生一种你精通搜索到的知识本身的错觉。
如何写一个Shell脚本 在写博客的时候，我通常会在文章中配图。图片一般会放在一个有固定格式的目录中，比如现在是2016年5月，我本地就会有一个名为$BLOG_HOME/images/2016/05的目录。由于使用的是markdown，在插入图片时我就不得不输入完整的图片路径，如：/images/2016/05/stack-overflow.png。但是我又不太记得路径中的images是单数(image)还是复数(images)，而且图片格式又可能是jpg,jpeg,gif或者png，我也经常会搞错，这会导致图片无法正确显示。另外，放入该目录的原始文件尺寸有可能比较大，我通常需要将其缩放成800像素宽（长度无所谓，因为文章总是要从上往下阅读）。
为了自动化这个步骤，我写了一个小的Shell脚本。当你输入一个文件名如：stack-overflow.png后，它会缩放这个文件到800像素宽，结果是一个新的图片文件，命名为stack-overflow-resized.png，另外它将符合markdown语法的文件路径拷贝到剪贴板里：/images/2016/05/stack-overflow-resized.png，这样我在文章正文中只需要用Command+V粘贴就可以了。
有了思路，写起来就很容易了。缩放图片的命令我是知道的：
$ convert -resize 800 stack-overflow.png stack-overflow-resized.png 但是要在文件明上加入-resized，需要分割文件名和文件扩展名，在Bash里如何做到这一点呢？Google一下：
FULLFILE=$1 FILENAME=$(basename &amp;#34;$FULLFILE&amp;#34;) EXTENSION=&amp;#34;${FILENAME##*.}&amp;#34; FILENAME=&amp;#34;${FILENAME%.*}&amp;#34; convert -resize 800 $FULLFILE $FILENAME-resized.EXTENSION 难看是有点难看，不过还是可以工作的。接下来是按照当前日期生成完整路径，date命令我是知道的，而且我知道它的format格式很复杂，而且跟JavaScript里Date对象的format又不太一样（事实上，世界上有多少种日期工具，基本上就有多少种格式）。再Google一下：
$ date +&amp;#34;/images/%Y/%m/&amp;#34; 最后一步将路径拷贝到剪贴板也容易，Mac下的pbcopy我也会用：echo一下字符串变量，再管道到pbcopy即可：
PREFIX=`date +&amp;#34;/images/%Y/%m/&amp;#34;` echo &amp;#34;$PREFIX$FILENAME-resized.EXTENSION&amp;#34; | pbcopy 但是将内容粘贴到markdown里之后，我发现这个脚本多了一个换行。我想这个应该是echo自己的行为吧，会给字符串自动加上一个换行符。Google一下，发现加上-n参数就可以解决这个问题。
好了，完整的脚本写好了：
#!/bin/bash FULLFILE=$1 FILENAME=$(basename &amp;#34;$FULLFILE&amp;#34;) EXTENSION=&amp;#34;${FILENAME##*.}&amp;#34; FILENAME=&amp;#34;${FILENAME%.*}&amp;#34; convert -resize 800 $FULLFILE $FILENAME-resized.EXTENSION PREFIX=`date +&amp;#34;/images/%Y/%m/&amp;#34;` echo -n &amp;#34;$PREFIX$FILENAME-resized.EXTENSION&amp;#34; | pbcopy 嗯，还不错，整个过程中就用了我十几分钟时间而已，以后我在写博客时插入图片就方便多了！
不过等等，好像有点不对劲儿，我回过头来看了看这段脚本：7行代码只有1行是我独立写的！没有Google的话，查看man date和man echo也可以解决其中一部分问题，不过文件扩展名部分估计又得花较长时间。
仔细分析一下，之前的成就感荡然无存。
更多的例子 我相信，过几周我再来写这样一个简单的脚本时，上面那一幕还是会出现。开发者的IDE的外延已经将Google和Stack Overflow集成了。很难想象没有这两个IDE的插件我要怎样工作。
其实除此之外，日常工作中这样的事情每时每刻都在发生：
 Ansible里如何创建一个给用户robot读写权限的目录？ Python 3中启动简单HTTPServer的命令是？ Spring Boot的Gradle String是？ Mongodb中如何为用户robot授权？ Gulp里一个Task依赖另一个Task怎么写？  等等等等，这个列表可以根据你的技术栈，偏向前端/后端的不同而不同，但是相同的是在Google和Stack Overflow上搜索，阅读会浪费很多时间，而这些本来都是可以避免的。</description>
      <content:encoded><![CDATA[<h2 id="高效幻象">高效幻象</h2>
<p>通过对自己的行为观察，我发现在很多时候，我以为我掌握了的知识和技能其实并不牢靠。我引以为豪的<code>高效</code>其实犹如一个彩色的肥皂泡，轻轻一碰就会破碎，散落一地。</p>
<h3 id="你可能只是精通搜索">你可能只是精通搜索</h3>
<p>我们现在所处的时代，信息爆炸，每个人每天都会接触，阅读很多的信息，快速消费，快速遗忘。那种每天早上起来如同皇帝批阅奏折的、虚假的误以为掌握知识的错觉，驱动我们进入一个恶性循环。</p>
<p>即使在我们真的打算解决问题，进行主动学习时，更多的也只是在熟练使用搜索引擎而已（在一个领域待久了，你所使用的关键字准确度自然要比新人高一些，仅此而已）。精通了高效率搜索之后，你会产生一种你<code>精通搜索到的知识本身</code>的<strong>错觉</strong>。</p>
<p><img loading="lazy" src="/images/2016/05/stackoverflow-oreilly.png" type="" alt="stack overflow"  /></p>
<h4 id="如何写一个shell脚本">如何写一个Shell脚本</h4>
<p>在写博客的时候，我通常会在文章中配图。图片一般会放在一个有固定格式的目录中，比如现在是2016年5月，我本地就会有一个名为<code>$BLOG_HOME/images/2016/05</code>的目录。由于使用的是<code>markdown</code>，在插入图片时我就不得不输入完整的图片路径，如：<code>/images/2016/05/stack-overflow.png</code>。但是我又不太记得路径中的<code>images</code>是单数(<code>image</code>)还是复数(<code>images</code>)，而且图片格式又可能是<code>jpg</code>,<code>jpeg</code>,<code>gif</code>或者<code>png</code>，我也经常会搞错，这会导致图片无法正确显示。另外，放入该目录的原始文件尺寸有可能比较大，我通常需要将其缩放成800像素宽（长度无所谓，因为文章总是要从上往下阅读）。</p>
<p>为了自动化这个步骤，我写了一个小的Shell脚本。当你输入一个文件名如：<code>stack-overflow.png</code>后，它会缩放这个文件到800像素宽，结果是一个新的图片文件，命名为<code>stack-overflow-resized.png</code>，另外它将符合<code>markdown</code>语法的文件路径拷贝到剪贴板里：<code>/images/2016/05/stack-overflow-resized.png</code>，这样我在文章正文中只需要用<code>Command+V</code>粘贴就可以了。</p>
<p>有了思路，写起来就很容易了。缩放图片的命令我是知道的：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ convert -resize <span class="m">800</span> stack-overflow.png stack-overflow-resized.png
</code></pre></div><p>但是要在文件明上加入<code>-resized</code>，需要分割文件名和文件扩展名，在<code>Bash</code>里如何做到这一点呢？Google一下：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh"><span class="nv">FULLFILE</span><span class="o">=</span><span class="nv">$1</span>

<span class="nv">FILENAME</span><span class="o">=</span><span class="k">$(</span>basename <span class="s2">&#34;</span><span class="nv">$FULLFILE</span><span class="s2">&#34;</span><span class="k">)</span>
<span class="nv">EXTENSION</span><span class="o">=</span><span class="s2">&#34;</span><span class="si">${</span><span class="nv">FILENAME</span><span class="p">##*.</span><span class="si">}</span><span class="s2">&#34;</span>
<span class="nv">FILENAME</span><span class="o">=</span><span class="s2">&#34;</span><span class="si">${</span><span class="nv">FILENAME</span><span class="p">%.*</span><span class="si">}</span><span class="s2">&#34;</span>

convert -resize <span class="m">800</span> <span class="nv">$FULLFILE</span> <span class="nv">$FILENAME</span>-resized.EXTENSION
</code></pre></div><p>难看是有点难看，不过还是可以工作的。接下来是按照当前日期生成完整路径，<code>date</code>命令我是知道的，而且我知道它的<code>format</code>格式很复杂，而且跟<code>JavaScript</code>里Date对象的<code>format</code>又不太一样（事实上，世界上有多少种日期工具，基本上就有多少种格式）。再Google一下：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ date +<span class="s2">&#34;/images/%Y/%m/&#34;</span>
</code></pre></div><p>最后一步将路径拷贝到剪贴板也容易，Mac下的<code>pbcopy</code>我也会用：<code>echo</code>一下字符串变量，再管道到<code>pbcopy</code>即可：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh"><span class="nv">PREFIX</span><span class="o">=</span><span class="sb">`</span>date +<span class="s2">&#34;/images/%Y/%m/&#34;</span><span class="sb">`</span>
<span class="nb">echo</span> <span class="s2">&#34;</span><span class="nv">$PREFIX$FILENAME</span><span class="s2">-resized.EXTENSION&#34;</span> <span class="p">|</span> pbcopy
</code></pre></div><p>但是将内容粘贴到<code>markdown</code>里之后，我发现这个脚本多了一个换行。我想这个应该是<code>echo</code>自己的行为吧，会给字符串自动加上一个换行符。Google一下，发现加上<code>-n</code>参数就可以解决这个问题。</p>
<p>好了，完整的脚本写好了：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh"><span class="cp">#!/bin/bash
</span><span class="cp"></span><span class="nv">FULLFILE</span><span class="o">=</span><span class="nv">$1</span>

<span class="nv">FILENAME</span><span class="o">=</span><span class="k">$(</span>basename <span class="s2">&#34;</span><span class="nv">$FULLFILE</span><span class="s2">&#34;</span><span class="k">)</span>
<span class="nv">EXTENSION</span><span class="o">=</span><span class="s2">&#34;</span><span class="si">${</span><span class="nv">FILENAME</span><span class="p">##*.</span><span class="si">}</span><span class="s2">&#34;</span>
<span class="nv">FILENAME</span><span class="o">=</span><span class="s2">&#34;</span><span class="si">${</span><span class="nv">FILENAME</span><span class="p">%.*</span><span class="si">}</span><span class="s2">&#34;</span>

convert -resize <span class="m">800</span> <span class="nv">$FULLFILE</span> <span class="nv">$FILENAME</span>-resized.EXTENSION

<span class="nv">PREFIX</span><span class="o">=</span><span class="sb">`</span>date +<span class="s2">&#34;/images/%Y/%m/&#34;</span><span class="sb">`</span>
<span class="nb">echo</span> -n <span class="s2">&#34;</span><span class="nv">$PREFIX$FILENAME</span><span class="s2">-resized.EXTENSION&#34;</span> <span class="p">|</span> pbcopy
</code></pre></div><p>嗯，还不错，整个过程中就用了我十几分钟时间而已，以后我在写博客时插入图片就方便多了！</p>
<p>不过等等，好像有点不对劲儿，我回过头来看了看这段脚本：7行代码只有1行是我独立写的！没有<code>Google</code>的话，查看<code>man date</code>和<code>man echo</code>也可以解决其中一部分问题，不过文件扩展名部分估计又得花较长时间。</p>
<p>仔细分析一下，之前的成就感荡然无存。</p>
<h4 id="更多的例子">更多的例子</h4>
<p>我相信，过几周我再来写这样一个简单的脚本时，上面那一幕还是会出现。开发者的IDE的外延已经将<code>Google</code>和<code>Stack Overflow</code>集成了。很难想象没有这两个IDE的<code>插件</code>我要怎样工作。</p>
<p>其实除此之外，日常工作中这样的事情每时每刻都在发生：</p>
<ol>
<li>Ansible里如何创建一个给用户<code>robot</code>读写权限的目录？</li>
<li>Python 3中启动简单HTTPServer的命令是？</li>
<li>Spring Boot的Gradle String是？</li>
<li>Mongodb中如何为用户<code>robot</code>授权？</li>
<li>Gulp里一个Task依赖另一个Task怎么写？</li>
</ol>
<p>等等等等，这个列表可以根据你的技术栈，偏向前端/后端的不同而不同，但是相同的是在<code>Google</code>和<code>Stack Overflow</code>上搜索，阅读会浪费很多时间，而这些本来都是可以避免的。</p>
<h3 id="肌肉记忆">肌肉记忆</h3>
<p>大脑在对信息存储上有很高级的设计，如果某件事情不值得记忆，大脑会自动过滤掉（比如我们很容易获得的搜索结果）。而对于那些频繁发生，计算结果又不会变化的信息，大脑会将其下放到“更低级别”的神经去记忆。比如各种运动中的肌肉记忆，习武之人梦寐以求的“拳拳服膺”，“不期然而然，莫知之而至”。</p>
<p>这里也有两个小例子：</p>
<h4 id="一个c语言的小程序">一个C语言的小程序</h4>
<p>上周末我买了一个茶轴的机械键盘，打开包装之后我很兴奋，赶紧插在我的笔记本上，打开一个编辑器，心说敲一些代码体验一下。几秒钟后，我发现敲出来的是：</p>
<div class="highlight"><pre class="chroma"><code class="language-c" data-lang="c"><span class="cp"># include &lt;stdio.h&gt;
</span><span class="cp"># include &lt;stdlib.h&gt;
</span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">*</span><span class="n">argv</span><span class="p">[])</span> <span class="p">{</span>
	<span class="k">if</span><span class="p">(</span><span class="n">argc</span> <span class="o">!=</span> <span class="mi">3</span><span class="p">)</span> <span class="p">{</span>
		<span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span> <span class="s">&#34;Usage: %s ip port</span><span class="se">\n</span><span class="s">&#34;</span><span class="p">,</span> <span class="n">argv</span><span class="p">[</span><span class="mi">0</span><span class="p">]);</span>
		<span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
	<span class="p">}</span>

	<span class="n">fprintf</span><span class="p">(</span><span class="n">stdout</span><span class="p">,</span> <span class="s">&#34;Connecting to %s %d</span><span class="se">\n</span><span class="s">&#34;</span><span class="p">,</span> <span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">atoi</span><span class="p">(</span><span class="n">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">]));</span>

	<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>然后在命令行里</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ gcc -o hello hello.c
$ ./hello
Usage: ./hello ip port

$ ./hello 10.180.1.1 <span class="m">9999</span>
Connecting to 10.180.1.1 <span class="m">9999</span>
</code></pre></div><p>整个过程极为流畅，上一次开发C代码已经是4年多前了。也就是说，我的手指已经记下了所有的这些命令：</p>
<ol>
<li>Linux下<code>main</code>函数的convention</li>
<li><code>fprintf</code>的签名</li>
<li><code>stderr/stdout</code>用法的区分</li>
<li><code>main</code>函数不同场景的返回值</li>
<li><code>gcc</code>命令的用法</li>
</ol>
<p>另外一个小例子是<code>vim</code>编辑器。我使用<code>vim</code>已经有很多年了，现在在任何一个Linux服务器上，编辑那些<code>/etc/nginx/nginx.conf</code>之类的配置文件时，手指就会<code>自动</code>的找到快捷键，<code>自动</code>的完成搜索，替换，跳转等等操作。</p>
<h3 id="刻意练习">刻意练习</h3>
<p>对比这两个例子，一方面我惊讶于自己目前对搜索引擎、<code>Stack Overflow</code>的依赖；一方面惊讶于<code>肌肉记忆力</code>的深远和神奇。结合一下两者，我发现自己的开发效率有望得到很大的提升。</p>
<p>比如上面列出的那些略显尴尬的问题，如果我的手指可以<code>自动</code>的敲出这些答案，那么节省下的搜索、等待、阅读的时间就可以用来干别的事情，比如跑步啊，骑车啊，去驾校学车被教练骂啊等等，总之，去过自己的生活。</p>
<p>这方面的书籍，博客都已经有很多，比如我们在ThoughtWorks University里实践的<code>Code Kata</code>，<code>JavaScript Dojo</code>，<code>TDD Dojo</code>之类，都已经证明其有效性。</p>
<p>如果你打算做一些相关的练习，从<code>Kata</code>开始是一个不错的选择。每个<code>Kata</code>都包含一个简单的编程问题，你需要不断的去练习它（同一个题目做20遍，50遍等）。前几次你是在解决问题本身，慢慢就会变成在审视自己的编程习惯，发现并改进（比如快捷键的使用，语法的熟悉程度等等），这样在实际工作中你会以外的发现自己的速度变快了，而且对于重构的信心会变大很多。其实道理也很简单：如果你总是赶着deadline来完成任务，怎么会有时间来做优化呢？</p>
<p>这里有一些参考资料和<code>Kata</code>的题目，可供参考：</p>
<ul>
<li><a href="https://sites.google.com/site/steveyegge2/practicing-programming">Practicing Programming</a></li>
<li><a href="https://blog.codinghorror.com/the-ultimate-code-kata/">The Ultimate Code Kata</a></li>
<li><a href="http://codekata.com/">一些Kata的题目</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>CI Pipeline上的性能测试</title>
      <link>https://icodeit.org/2016/02/performance-testing-in-ci/</link>
      <pubDate>Sat, 20 Feb 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/02/performance-testing-in-ci/</guid>
      <description>Web站点的响应速度 雅虎在2006年就发布了一份提升Web站点响应速度的最佳实践指南。该指南包含了35条规则，分为7个类别。这些规则已经被广泛使用，并指导人们在新的站点设计时更有针对性的考虑问题。这份指南已经成了Web前端性能度量的一个事实标准了。
YSlow是一个基于这份指南的测试工具，它可以测试一个站点是否“慢”，以及为什么“慢”？你可以通过很多方式来使用YSlow，比如Firefox，Chrome的插件，命令行工具，甚至PhantomJS这样的无头（Headless）浏览器。YSlow会检测你的站点中的资源是否没有压缩，是否缺失了超时设置，更进一步，它还会检测你的JS/CSS是否已经压缩/精简化，图片的尺寸，是否使用了CDN等等很多的维度。它还可以生成很多格式的报告，比如打分信息，TAP协议的输出，以及junit测试报告的格式。
我们这里讨论如何在持续集成服务器上设置一个YSlow任务，这个任务会在每次构建之后，测试你应用的性能指标，以帮助你更快的发现和定位问题。当然，我推荐你在staging环境，很多开发者在测试环境，本地开发环境都会启动很多对Debug友好的设置，比如未压缩的JS/CSS，没有超时设置的响应等，这会导致该构建任务的打分不够准确。
搭建CI环境 按照传统方式，如果要搭建一个这样的CI任务，我们需要至少做这样一些事情：
 安装JDK 安装Jenkins 安装PhantomJS 安装YSlow.js脚本  然后设置环境变量，在Jenkins上创建任务，并运行YSlow.js脚本。这个任务很简单，只需要设置好参数，然后将结果输出为Jenkins上的报告即可。比如：
$ phantomjs /var/share/yslow.js -i grade -threshold &amp;#34;B&amp;#34; -f junit \ http://bookmarks-frontend.s3-website-us-west-2.amazonaws.com/ &amp;gt; yslow.xml  -i grade 展示打分（grade）信息（还可以是basic/stats/all）等 -threshold &amp;quot;B&amp;quot; 指定失败的阈值为B -f junit 输出为junit识别的XML格式  这里的阈值可以是数字（0-100分），字母（A-F级别）或者一个JSON字符串（混合使用）
-threshold &amp;#39;{&amp;#34;overall&amp;#34;: &amp;#34;B&amp;#34;, &amp;#34;ycdn&amp;#34;: &amp;#34;F&amp;#34;, &amp;#34;yexpires&amp;#34;: 85}&amp;#39; 上面的命令会测试站点http://bookmarks-frontend.s3-website-us-west-2.amazonaws.com/的各项指标，并应用雅虎的那35条规则，并最终生成一个junit测试报告格式的文件：yslow.xml。
但是维护CI环境是一个比较麻烦的事情，而且既然每个项目都可能会用到这样的基础设施，一种好的做法就是将其做成一个镜像保存起来，以方便其他项目的复用！这里我们使用docker来安装和配置我们的CI环境，配置完成之后，我们可以将docker的镜像分享给其他团队，也可以供我们在下一个项目中使用。
基于docker/docker-compose的环境搭建 在docker出现之前，我们要搭建一个测试或者staging环境，往往需要很多个不同角色的机器：有专门的数据库服务器，文件服务器，缓存服务器，Web服务器，反向代理等等。这样在成本上显然是个不小的开销，如果将所有不同的组件部署在同一台机器上，则又可能互相干扰，只需要一个小小的失误，整个系统就需要重新配置。更可怕的是，这个环境和生产系统不一致，那么很可能真实的错误要等到系统上线之后才会被发现。
比如在2012年，我所在的一个项目中，客户的系统采用传统的J2EE架构。本地开发中，我们使用了Jetty作为容器，而测试和Staging环境使用了Tomcat。由于Tomcat对空格的处理和Jetty有所不同，我们在本地测试通过，并且运行良好的代码，在Staging变得完全不能工作。这个问题花费了团队很多时间来排查错误。
在docker出现之后，我们可以在一台物理机器上运行多个互不干涉的容器，每个容器可以是一个组件（比如运行数据库的容器，Web服务器容器等等）。这样不但缩减了成本，而且可以让我们的环境尽可能和生产环境一致（有的项目甚至直接将CI出来的镜像应用到生产中）。不过对多个容器的管理是一个很麻烦的事情，好在docker提供了docker-compose工具来解决这个问题。使用docker-compose可以定义一组互相独立，但是又可以协作在一起的容器，这样我们可以很容易的搭建一个仿生产环境。
比如我们可以定义个docker-compse.yml
app:build:.links:- db:postgresports:- 8000:8000volumes:- .:/appworking_dir:/appentrypoint:/app/start.shenvironment:JDBC_DATABASE_URL:jdbc:postgresql://postgres:5432/bookmarksDATABASE_USER:bookmarks-userDATABASE_PASS:bookmarks-passworddb:image:postgres:9.3ports:- 5432:5432environment:POSTGRES_DB:bookmarksPOSTGRES_USER:bookmarks-userPOSTGRES_PASSWORD:bookmarks-password这个docker-compose定义了两个组件，app和db。db使用了postgres:9.3镜像，并设置了自己的环境变量。app则从当前目录.构建一个新的镜像，app与db通过links属性连接起来。
如果在当前目录执行docker-compose build命令，docker-compose会找到本地的Dockerfile，然后构建出一个docker的镜像，并启动该容器，同时，它还会启动postgres:9.3容器作为数据库组件。这样我们的环境就被完整的搭建好了。
搭建CI环境 app:build:.ports:- 8080:8080- 50000:50000volumes:- ./data:/var/jenkins_home这个配置，表明我们会根据当前目录的Dockerfile来构建一个镜像。
通过命令volumns，我们将本地目录./data映射为jenkins_home，这样我们定义的job信息，以及插件的安装都会放到本地的目录中，方便管理。配置完成之后，构建并启动该容器：
FROM jenkins:latest # Env ENV PHANTOMJS_VERSION 1.</description>
      <content:encoded><![CDATA[<h2 id="web站点的响应速度">Web站点的响应速度</h2>
<p>雅虎在2006年就发布了一份提升Web站点响应速度的<a href="https://developer.yahoo.com/performance/rules.html">最佳实践指南</a>。该指南包含了35条规则，分为7个类别。这些规则已经被广泛使用，并指导人们在新的站点设计时更有针对性的考虑问题。这份指南已经成了Web前端性能度量的一个事实标准了。</p>
<p><a href="http://yslow.org/">YSlow</a>是一个基于这份指南的测试工具，它可以测试一个站点是否“慢”，以及为什么“慢”？你可以通过很多方式来使用<a href="http://yslow.org/">YSlow</a>，比如Firefox，Chrome的插件，命令行工具，甚至PhantomJS这样的无头（Headless）浏览器。YSlow会检测你的站点中的资源是否没有压缩，是否缺失了超时设置，更进一步，它还会检测你的JS/CSS是否已经压缩/精简化，图片的尺寸，是否使用了CDN等等很多的维度。它还可以生成很多格式的报告，比如打分信息，TAP协议的输出，以及junit测试报告的格式。</p>
<p>我们这里讨论如何在持续集成服务器上设置一个<code>YSlow</code>任务，这个任务会在每次构建之后，测试你应用的性能指标，以帮助你更快的发现和定位问题。当然，我推荐你在<code>staging</code>环境，很多开发者在测试环境，本地开发环境都会启动很多对<code>Debug</code>友好的设置，比如未压缩的JS/CSS，没有超时设置的响应等，这会导致该构建任务的<code>打分</code>不够准确。</p>
<p><img loading="lazy" src="/images/2016/02/jenkins-report-resized.png" type="" alt="jenkins failure"  /></p>
<h3 id="搭建ci环境">搭建CI环境</h3>
<p>按照传统方式，如果要搭建一个这样的CI任务，我们需要至少做这样一些事情：</p>
<ul>
<li>安装JDK</li>
<li>安装Jenkins</li>
<li>安装<a href="http://phantomjs.org/">PhantomJS</a></li>
<li>安装<a href="http://yslow.org/phantomjs/">YSlow.js脚本</a></li>
</ul>
<p>然后设置环境变量，在Jenkins上创建任务，并运行YSlow.js脚本。这个任务很简单，只需要设置好参数，然后将结果输出为Jenkins上的报告即可。比如：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ phantomjs /var/share/yslow.js -i grade -threshold <span class="s2">&#34;B&#34;</span> -f junit <span class="se">\
</span><span class="se"></span>http://bookmarks-frontend.s3-website-us-west-2.amazonaws.com/ &gt; yslow.xml
</code></pre></div><ul>
<li><code>-i grade</code> 展示打分（grade）信息（还可以是basic/stats/all）等</li>
<li><code>-threshold &quot;B&quot;</code> 指定失败的阈值为B</li>
<li><code>-f junit</code> 输出为<code>junit</code>识别的XML格式</li>
</ul>
<p>这里的阈值可以是数字（0-100分），字母（A-F级别）或者一个JSON字符串（混合使用）</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">-threshold <span class="s1">&#39;{&#34;overall&#34;: &#34;B&#34;, &#34;ycdn&#34;: &#34;F&#34;, &#34;yexpires&#34;: 85}&#39;</span>
</code></pre></div><p>上面的命令会测试站点<code>http://bookmarks-frontend.s3-website-us-west-2.amazonaws.com/</code>的各项指标，并应用雅虎的那35条规则，并最终生成一个<code>junit</code>测试报告格式的文件：<code>yslow.xml</code>。</p>
<p>但是维护CI环境是一个比较麻烦的事情，而且既然每个项目都可能会用到这样的<code>基础设施</code>，一种好的做法就是将其做成一个<code>镜像</code>保存起来，以方便其他项目的复用！这里我们使用<code>docker</code>来安装和配置我们的CI环境，配置完成之后，我们可以将<code>docker</code>的镜像分享给其他团队，也可以供我们在下一个项目中使用。</p>
<h3 id="基于dockerdocker-compose的环境搭建">基于docker/docker-compose的环境搭建</h3>
<p>在<a href="https://www.docker.com/">docker</a>出现之前，我们要搭建一个<code>测试</code>或者<code>staging</code>环境，往往需要很多个不同角色的机器：有专门的数据库服务器，文件服务器，缓存服务器，Web服务器，反向代理等等。这样在成本上显然是个不小的开销，如果将所有不同的组件部署在同一台机器上，则又可能互相干扰，只需要一个小小的失误，整个系统就需要重新配置。更可怕的是，这个环境和生产系统不一致，那么很可能真实的错误要等到系统上线之后才会被发现。</p>
<p>比如在2012年，我所在的一个项目中，客户的系统采用传统的J2EE架构。本地开发中，我们使用了Jetty作为容器，而<code>测试</code>和<code>Staging</code>环境使用了Tomcat。由于Tomcat对空格的处理和Jetty有所不同，我们在本地测试通过，并且运行良好的代码，在<code>Staging</code>变得完全不能工作。这个问题花费了团队很多时间来排查错误。</p>
<p>在<code>docker</code>出现之后，我们可以在一台物理机器上运行多个互不干涉的容器，每个容器可以是一个组件（比如运行数据库的容器，Web服务器容器等等）。这样不但缩减了成本，而且可以让我们的环境尽可能和生产环境一致（有的项目甚至直接将CI出来的镜像应用到生产中）。不过对多个容器的管理是一个很麻烦的事情，好在<code>docker</code>提供了<a href="https://docs.docker.com/compose/overview/">docker-compose</a>工具来解决这个问题。使用<code>docker-compose</code>可以定义一组互相独立，但是又可以协作在一起的容器，这样我们可以很容易的搭建一个<code>仿生产</code>环境。</p>
<p>比如我们可以定义个<code>docker-compse.yml</code></p>
<div class="highlight"><pre class="chroma"><code class="language-yml" data-lang="yml"><span class="nt">app</span><span class="p">:</span><span class="w">
</span><span class="w">  </span><span class="nt">build</span><span class="p">:</span><span class="w"> </span><span class="l">.</span><span class="w">
</span><span class="w">  </span><span class="nt">links</span><span class="p">:</span><span class="w">
</span><span class="w">    </span>- <span class="l">db:postgres</span><span class="w">
</span><span class="w">  </span><span class="nt">ports</span><span class="p">:</span><span class="w">
</span><span class="w">    </span>- <span class="m">8000</span><span class="p">:</span><span class="m">8000</span><span class="w">
</span><span class="w">  </span><span class="nt">volumes</span><span class="p">:</span><span class="w">
</span><span class="w">    </span>- <span class="l">.:/app</span><span class="w">
</span><span class="w">  </span><span class="nt">working_dir</span><span class="p">:</span><span class="w"> </span><span class="l">/app</span><span class="w">
</span><span class="w">  </span><span class="nt">entrypoint</span><span class="p">:</span><span class="w"> </span><span class="l">/app/start.sh</span><span class="w">
</span><span class="w">  </span><span class="nt">environment</span><span class="p">:</span><span class="w">
</span><span class="w">    </span><span class="nt">JDBC_DATABASE_URL</span><span class="p">:</span><span class="w"> </span><span class="l">jdbc:postgresql://postgres:5432/bookmarks</span><span class="w">
</span><span class="w">    </span><span class="nt">DATABASE_USER</span><span class="p">:</span><span class="w"> </span><span class="l">bookmarks-user</span><span class="w">
</span><span class="w">    </span><span class="nt">DATABASE_PASS</span><span class="p">:</span><span class="w"> </span><span class="l">bookmarks-password</span><span class="w">
</span><span class="w">
</span><span class="w"></span><span class="nt">db</span><span class="p">:</span><span class="w">
</span><span class="w">  </span><span class="nt">image</span><span class="p">:</span><span class="w"> </span><span class="l">postgres:9.3</span><span class="w">
</span><span class="w">  </span><span class="nt">ports</span><span class="p">:</span><span class="w">
</span><span class="w">    </span>- <span class="m">5432</span><span class="p">:</span><span class="m">5432</span><span class="w">
</span><span class="w">  </span><span class="nt">environment</span><span class="p">:</span><span class="w">
</span><span class="w">    </span><span class="nt">POSTGRES_DB</span><span class="p">:</span><span class="w"> </span><span class="l">bookmarks</span><span class="w">
</span><span class="w">    </span><span class="nt">POSTGRES_USER</span><span class="p">:</span><span class="w"> </span><span class="l">bookmarks-user</span><span class="w">
</span><span class="w">    </span><span class="nt">POSTGRES_PASSWORD</span><span class="p">:</span><span class="w"> </span><span class="l">bookmarks-password</span><span class="w">
</span></code></pre></div><p>这个<code>docker-compose</code>定义了两个组件，<code>app</code>和<code>db</code>。<code>db</code>使用了<code>postgres:9.3</code>镜像，并设置了自己的环境变量。<code>app</code>则从当前目录<code>.</code>构建一个新的镜像，<code>app</code>与<code>db</code>通过<code>links</code>属性连接起来。</p>
<p>如果在当前目录执行<code>docker-compose build</code>命令，<code>docker-compose</code>会找到本地的<code>Dockerfile</code>，然后构建出一个<code>docker</code>的镜像，并启动该容器，同时，它还会启动<code>postgres:9.3</code>容器作为数据库组件。这样我们的环境就被完整的搭建好了。</p>
<h4 id="搭建ci环境-1">搭建CI环境</h4>
<div class="highlight"><pre class="chroma"><code class="language-yml" data-lang="yml"><span class="nt">app</span><span class="p">:</span><span class="w">
</span><span class="w">  </span><span class="nt">build</span><span class="p">:</span><span class="w"> </span><span class="l">.</span><span class="w">
</span><span class="w">  </span><span class="nt">ports</span><span class="p">:</span><span class="w">
</span><span class="w">    </span>- <span class="m">8080</span><span class="p">:</span><span class="m">8080</span><span class="w">
</span><span class="w">    </span>- <span class="m">50000</span><span class="p">:</span><span class="m">50000</span><span class="w">
</span><span class="w">  </span><span class="nt">volumes</span><span class="p">:</span><span class="w">
</span><span class="w">    </span>- <span class="l">./data:/var/jenkins_home</span><span class="w">
</span></code></pre></div><p>这个配置，表明我们会根据当前目录的<code>Dockerfile</code>来构建一个镜像。</p>
<p>通过命令<code>volumns</code>，我们将本地目录<code>./data</code>映射为<code>jenkins_home</code>，这样我们定义的job信息，以及插件的安装都会放到本地的目录中，方便管理。配置完成之后，构建并启动该容器：</p>
<pre><code>FROM jenkins:latest

# Env
ENV PHANTOMJS_VERSION 1.9.6
ENV PHANTOMJS_YSLOW_VERSION 3.1.8
ENV SHARE_BIN /var/share

# Install stuff by using root
USER root
RUN apt-get update
RUN apt-get upgrade -y
RUN apt-get install -y git wget libfreetype6 libfontconfig bzip2

RUN mkdir -p $SHARE_BIN

RUN wget -q --no-check-certificate -O /tmp/phantomjs-$PHANTOMJS_VERSION-linux-x86_64.tar.bz2 \
https://bitbucket.org/ariya/phantomjs/downloads/phantomjs-$PHANTOMJS_VERSION-linux-x86_64.tar.bz2
RUN tar -xjf /tmp/phantomjs-$PHANTOMJS_VERSION-linux-x86_64.tar.bz2 -C /tmp
RUN rm -f /tmp/phantomjs-$PHANTOMJS_VERSION-linux-x86_64.tar.bz2
RUN mv /tmp/phantomjs-$PHANTOMJS_VERSION-linux-x86_64/ $SHARE_BIN/phantomjs
RUN ln -s $SHARE_BIN/phantomjs/bin/phantomjs /usr/bin/phantomjs

RUN wget -q --no-check-certificate -O /tmp/yslow-phantomjs-$PHANTOMJS_YSLOW_VERSION.zip \
http://yslow.org/yslow-phantomjs-$PHANTOMJS_YSLOW_VERSION.zip
RUN unzip /tmp/yslow-phantomjs-$PHANTOMJS_YSLOW_VERSION.zip -d $SHARE_BIN/
USER jenkins
</code></pre><p>执行下面的命令来设置并启动CI服务器：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">docker-compose up
</code></pre></div><p><img loading="lazy" src="/images/2016/02/jenkins-in-docker-resized.png" type="" alt="jenkins in docker"  /></p>
<p>创建新任务，并指定该任务执行的命令为：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ phantomjs /var/share/yslow.js -i grade -threshold <span class="s2">&#34;B&#34;</span> -f junit <span class="se">\
</span><span class="se"></span>http://bookmarks-frontend.s3-website-us-west-2.amazonaws.com/ &gt; yslow.xml
</code></pre></div><p>由于此时<code>phantomjs</code>已经被安装到了容器中，我们可以直接在jenkins中使用。运行结束之后，这个命令会生成一个报告：</p>
<p><img loading="lazy" src="/images/2016/02/jenkins-report-resized.png" type="" alt="jenkins failure"  /></p>
<ul>
<li>没有压缩内容</li>
<li>没有添加过期的头信息</li>
</ul>
<p>在产品环境，我们需要使用反向代理来添加这些头信息，以保证最终用户在使用Web站点时的体验。</p>
<h3 id="总结">总结</h3>
<p>我们只需要很少的配置就可以设置好一个工作良好的CI任务，这样在程序员某天引入了未经压缩的JS/CSS或者UX不小心提供了巨大而未经处理的图片时，你可以尽快的得到通知，并在正是上线之前发现这些问题。</p>
<p><a href="https://github.com/abruzzi/phantomjs-yslow">代码配置</a>在这里。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>技术陷阱</title>
      <link>https://icodeit.org/2016/02/pitfall-of-technology/</link>
      <pubDate>Sun, 14 Feb 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/02/pitfall-of-technology/</guid>
      <description>知识漩涡 只需稍加留意，我们就会发现自己被各种技术，工具包围。ThoughtWorks的技术雷达差不多每隔半年就会更新一次，而项目中更是会遇到很多已经从技术雷达上消失的技术，项目上的旧技术/旧框架还在服役，新的技术/工具/语言/框架又在迅速的出现，有些昙花一现，迅速被新的后来者取代，有的留下来了，不过也都在不断的演化，改变（不兼容的API，不同的版本等等随处可见）。
如果你不幸是一个前端工程师，那么这个更新速度还要更加迅速。三年前Backbone是主流，两年前是Angular.js，去年是React，紧接着Flux，Reflux等作为React的扩展而成为了新的主流；Grunt流行过一段时间，很快被Gulp替代，而新的Webpack又依稀有大一统的趋势。每周几乎都能看到新的框架涌现，双向绑定，虚拟DOM，事件代理，同构，后端渲染，更友好的语法糖，更快的执行速度等等等等，几乎任何一个方向都有无穷无尽的变化。
而后端也好不到哪里去，容器技术，Web框架，ORM，构建脚本，自动化测试工具，依赖管理，应用服务器等等，你总有很多的选项，却又无法在事先区分到底哪个技术/工具更靠谱，更适合项目。
置身其中，往往有眼花缭乱，应接不暇的感觉。知识工作者当然需要终身不断的学习，但是像目前这种节奏，我很怀疑这是一种健康的状态。周围经常有人抱怨，好不容易上手了一个前端的MVC框架，一看周围的项目，大家已经在spike另外的框架/工具了（这意味着你在项目上无法使用该框架了……）。仅仅从学习的速度上来讲，我们已经远远无法跟上科技演化的节奏了，这是人类自身的一种限制。
知识的陷阱 假设你在一个Ruby项目上，学习了Rails/ActiveRecord/RSpec/MySQL。如果下一个项目还是Ruby，同样的技术站，你会觉得这是一种重复，因为除了业务逻辑、业务对象变化了之外，并没有新的内容，还是同样的技术。如果下一个项目是Python，技术栈变成了Django/nose/PostgreSQL，你可能会觉得有所提升，因为学到了不同的技术，框架，共建工具，测试工具等等，其实仔细观察，这还是一种重复，古人云：“换汤不换药”者，是也。
在目前我们所处的时代，信息以远远超过人们能接受的速度不断的被创造出来，一方面信息传播的速度大大提升了，另一方面是信息传播的渠道也极具多样化。我们无时无刻不被过载的信息包围着，即使你不主动的去尝试获取新的信息，手机App里的微信，微博，Flipboard，Pocket，知乎，开发者头条，Feedly，果壳，丁香园等等的推送已经足以提供给你足够的信息（大部分甚至都来不及消费就变成了历史信息而被忽略）。
以我自己为例，从2015年10月到现在（2016年2月），我学习了很多东西，看一下下面这张图：
图中的灰色方框中的内容是项目要求的知识，另外的则是我根据自己的兴趣学习的（两者基本上各占一半）。事实上有很多内容（尤其是根据自己兴趣学习的）在真正要使用时，可能还需要学一遍。这些内容可能让我产生了我学到了好多东西的错觉。其实这个在另一个角度显现了技术人员的一个误区：以为自己可以掌握所有软件开发相关的知识（或者说太过于纵容自己的好奇心和兴趣）。
过载的信息 身处这样的信息过载环境，我们很难不为自己对信息的缺乏而感到不安，担心自己错过了什么重要的信息，这种担心和焦虑会促使我们进一步将时间消耗在对信息的获取上，从而更无暇思考什么是真正重要的。
《如何阅读一本书》将书分为两类：一种是提供资讯/信息（known）的，一种是帮助你理解（understand）信息的。相对于理解来讲，资讯本身其实并不那么重要。我们大部分人目前采用的碎片化的阅读方式无法提供给我们足够的“理解力”。我们都有这样的体验，有些书特别耗费脑力，读起来很累，而另一些书则非常轻松，易于消费。碎片话的阅读方式易于消费，只需要很少的思考就可以读懂，但是危害严重，它们并不会让帮助你提升理解力。
但是直觉上我们会选择容易的事情来做，虽然这种浅层次的阅读只对扩展信息/资讯有帮助，对提升理解力则几乎无用。而我们在处理日常工作中的问题时，能真正帮助的，只有理解了的那部分知识。我在2014年，曾经有几个月屏蔽了所有微信，微博，内容聚合类的应用，也尽量少的去技术论坛，每天就是写代码，读纸质书，除了最初几天的忐忑之外，整个过程的收获非常大（而且也没有漏掉任何重要的信息）。
知识框架 技术人员有时候会有一种想要把所有技术都掌握的执念，这在局外人来看是一种荒诞不经的想法，但是置身其中，你很难看出这一点。毕竟，有意思的东西是在太多了，各种范式的编程语言，编译器技术，人工智能，数据可视化，地理信息系统，嵌入式设备，软硬件结合，大数据，自动化测试等等，每一个方向都有无穷无尽的有意思的东西。
但是在知识规模如此巨大的今天，一个人是无法掌握所有技术的（更不用说新的技术还在不断的涌现出来）！这就要求我们有节制的来聚焦在某些技术上，而视其他技术如无物。当然这需要很大的勇气和魄力，不过唯有如此，技术人员才有可能有真正的长进和成就。
我基于自己的经验，绘制了一个Web开发方面的知识框架，这个框架上包含了一个比较全的技能/知识集合，也是我认为一个Web开发人员应该掌握的一些知识点。
在成为一个专家之前，你需要先对要学习的领域有一个全面的认识。也就是说，做Web开发，需要尽可能覆盖到这个框架上的所有点。一旦完成了这棵树上的所有节点，就不用再去做第二次了，这时候你可以尝试找到树上的某一个分支，深入下去。这个听起来好像和我之前文章中的观点有所矛盾，其实不然。我在《我们真的缺前端工程师》一文中提到过，工程师不应该将自己束缚在前端开发上，要了解整个软件开发的全生命周期。这里的观点其实是一致的，即首先要了解软件开发全生命周期中的所有节点，然后再有所侧重的去找自己的兴趣点来发展，即：先建立广度，再建立深度。
应对方法 对于知识的陷阱 当因自己的兴趣（而不是项目驱动，也就是没有实际的土壤来验证）而想要学习一个新的知识时，对照知识框架，如果发现你已经在历史上学过它了，那就强迫自己放弃这个念头。比如如果你很熟悉用rspec来编写测试，忽然有一天心血来潮，想要学习JUnit，正确的做法就是泡杯茶，等这种冲动自己过去。相信我，一旦有了Java项目，你可以非常快速的掌握JUnit，而且很快会找到对应的feature，就像一个长期工作在Java技术栈上的同事那样！
对于过载的信息 实践中，首先要令自己相信：你无法掌握所有的知识，即使仅仅在软件开发领域。有了这个大前提之后，你只需要采取先建立广度，再建立深度的原则即可：
 做减法（在建立了知识框架之后，有针对性的学习） 主动，深度阅读经典 为那些有趣但非自己关注方向的知识赋予较低的优先级  另外，还可以尝试将微信，微博关闭一段时间，或者至少可以不去点那些朋友圈里的《老X聊微服务》或者《12个你不知道的Sublime技巧》文章，保持专注，保持简单。</description>
      <content:encoded><![CDATA[<h2 id="知识漩涡">知识漩涡</h2>
<p>只需稍加留意，我们就会发现自己被各种技术，工具包围。<a href="https://www.thoughtworks.com/radar">ThoughtWorks的技术雷达</a>差不多每隔半年就会更新一次，而项目中更是会遇到很多已经从技术雷达上消失的技术，项目上的旧技术/旧框架还在服役，新的技术/工具/语言/框架又在迅速的出现，有些昙花一现，迅速被新的后来者取代，有的留下来了，不过也都在不断的演化，改变（不兼容的API，不同的版本等等随处可见）。</p>
<p>如果你不幸是一个前端工程师，那么这个更新速度还要更加迅速。三年前<code>Backbone</code>是主流，两年前是<code>Angular.js</code>，去年是<code>React</code>，紧接着<code>Flux</code>，<code>Reflux</code>等作为React的扩展而成为了新的主流；<code>Grunt</code>流行过一段时间，很快被<code>Gulp</code>替代，而新的<code>Webpack</code>又依稀有大一统的趋势。每周几乎都能看到新的框架涌现，双向绑定，虚拟DOM，事件代理，同构，后端渲染，更友好的语法糖，更快的执行速度等等等等，几乎任何一个方向都有无穷无尽的变化。</p>
<p><img loading="lazy" src="/images/2016/02/full-stack-js-resized.png" type="" alt="full stack js"  /></p>
<p>而后端也好不到哪里去，容器技术，Web框架，ORM，构建脚本，自动化测试工具，依赖管理，应用服务器等等，你总有很多的选项，却又无法在事先区分到底哪个技术/工具更靠谱，更适合项目。</p>
<p>置身其中，往往有眼花缭乱，应接不暇的感觉。知识工作者当然需要<strong>终身不断</strong>的学习，但是像目前这种节奏，我很怀疑这是一种健康的状态。周围经常有人抱怨，好不容易上手了一个前端的MVC框架，一看周围的项目，大家已经在spike另外的框架/工具了（这意味着你在项目上无法使用该框架了……）。仅仅从学习的速度上来讲，我们已经远远无法跟上科技演化的节奏了，这是<strong>人类</strong>自身的一种限制。</p>
<h3 id="知识的陷阱">知识的陷阱</h3>
<p>假设你在一个<code>Ruby</code>项目上，学习了<code>Rails/ActiveRecord/RSpec/MySQL</code>。如果下一个项目还是<code>Ruby</code>，同样的技术站，你会觉得这是一种重复，因为除了业务逻辑、业务对象变化了之外，并没有新的内容，还是<strong>同样的</strong>技术。如果下一个项目是<code>Python</code>，技术栈变成了<code>Django/nose/PostgreSQL</code>，你可能会觉得有所提升，因为学到了不同的技术，框架，共建工具，测试工具等等，其实仔细观察，这还是一种重复，古人云：“换汤不换药”者，是也。</p>
<p>在目前我们所处的时代，信息以远远超过人们能接受的速度不断的被创造出来，一方面信息传播的速度大大提升了，另一方面是信息传播的渠道也极具多样化。我们无时无刻不被过载的信息包围着，即使你不主动的去尝试获取新的信息，手机App里的微信，微博，Flipboard，Pocket，知乎，开发者头条，Feedly，果壳，丁香园等等的推送已经足以提供给你足够的信息（大部分甚至都来不及消费就变成了历史信息而被忽略）。</p>
<p>以我自己为例，从2015年10月到现在（2016年2月），我学习了很多东西，看一下下面这张图：</p>
<p><img loading="lazy" src="/images/2016/02/tech-tree.png" type="" alt="tech tree"  /></p>
<p>图中的灰色方框中的内容是项目要求的知识，另外的则是我根据自己的兴趣学习的（两者基本上各占一半）。事实上有很多内容（尤其是根据自己兴趣学习的）在真正要使用时，可能还需要学一遍。这些内容可能让我产生了<strong>我学到了好多东西</strong>的错觉。其实这个在另一个角度显现了技术人员的一个误区：以为自己可以掌握所有软件开发相关的知识（或者说太过于纵容自己的好奇心和兴趣）。</p>
<h2 id="过载的信息">过载的信息</h2>
<p>身处这样的信息过载环境，我们很难不为自己对信息的缺乏而感到不安，担心自己错过了什么重要的信息，这种担心和焦虑会促使我们进一步将时间消耗在对信息的获取上，从而更无暇思考什么是真正重要的。</p>
<p><a href="http://book.douban.com/subject/1013208/">《如何阅读一本书》</a>将书分为两类：一种是提供资讯/信息（known）的，一种是帮助你理解（understand）信息的。相对于理解来讲，资讯本身其实并不那么重要。我们大部分人目前采用的碎片化的阅读方式无法提供给我们足够的“理解力”。我们都有这样的体验，有些书特别耗费脑力，读起来很累，而另一些书则非常轻松，易于消费。碎片话的阅读方式易于消费，只需要很少的思考就可以读懂，但是危害严重，它们并不会让帮助你提升理解力。</p>
<p>但是直觉上我们会选择容易的事情来做，虽然这种浅层次的阅读只对扩展信息/资讯有帮助，对提升理解力则几乎无用。而我们在处理日常工作中的问题时，能真正帮助的，只有理解了的那部分知识。我在2014年，曾经有几个月屏蔽了所有微信，微博，内容聚合类的应用，也尽量少的去技术论坛，每天就是写代码，读纸质书，除了最初几天的忐忑之外，整个过程的收获非常大（而且也没有漏掉任何重要的信息）。</p>
<h3 id="知识框架">知识框架</h3>
<p>技术人员有时候会有一种想要把所有技术都掌握的<code>执念</code>，这在局外人来看是一种荒诞不经的想法，但是置身其中，你很难看出这一点。毕竟，有意思的东西是在太多了，各种范式的编程语言，编译器技术，人工智能，数据可视化，地理信息系统，嵌入式设备，软硬件结合，大数据，自动化测试等等，每一个方向都有无穷无尽的有意思的东西。</p>
<p>但是在知识规模如此巨大的今天，一个人是无法掌握所有技术的（更不用说新的技术还在不断的涌现出来）！这就要求我们有节制的来聚焦在某些技术上，而视其他技术如无物。当然这需要很大的勇气和魄力，不过唯有如此，技术人员才有可能有真正的长进和成就。</p>
<p>我基于自己的经验，绘制了一个<code>Web开发</code>方面的知识框架，这个框架上包含了一个比较全的技能/知识集合，也是我认为一个<code>Web开发</code>人员应该掌握的一些知识点。</p>
<p><img loading="lazy" src="/images/2016/02/knowledge-framework.png" type="" alt="knowledge framework"  /></p>
<p>在成为一个专家之前，你需要先对要学习的领域有一个全面的认识。也就是说，做<code>Web开发</code>，需要尽可能覆盖到这个框架上的所有点。一旦完成了这棵树上的所有节点，就不用再去做第二次了，这时候你可以尝试找到树上的某一个分支，深入下去。这个听起来好像和我之前文章中的观点有所矛盾，其实不然。我在<a href="http://icodeit.org/2015/06/do-we-really-short-for-front-end-developer/">《我们真的缺前端工程师》</a>一文中提到过，工程师不应该将自己束缚在前端开发上，要了解整个软件开发的全生命周期。这里的观点其实是一致的，即首先要了解软件开发全生命周期中的所有节点，然后再有所侧重的去找自己的兴趣点来发展，即：先建立广度，再建立深度。</p>
<h2 id="应对方法">应对方法</h2>
<h3 id="对于知识的陷阱">对于知识的陷阱</h3>
<p>当因自己的兴趣（而不是项目驱动，也就是没有实际的土壤来验证）而想要学习一个新的知识时，对照<code>知识框架</code>，如果发现你已经在历史上学过它了，那就强迫自己放弃这个念头。比如如果你很熟悉用<code>rspec</code>来编写测试，忽然有一天心血来潮，想要学习JUnit，正确的做法就是泡杯茶，等这种冲动自己过去。相信我，一旦有了Java项目，你可以非常快速的掌握JUnit，而且很快会找到对应的feature，就像一个长期工作在Java技术栈上的同事那样！</p>
<h3 id="对于过载的信息">对于过载的信息</h3>
<p>实践中，首先要令自己相信：<code>你无法掌握所有的知识，即使仅仅在软件开发领域</code>。有了这个大前提之后，你只需要采取<code>先建立广度，再建立深度</code>的原则即可：</p>
<ul>
<li>做减法（在建立了<code>知识框架</code>之后，有针对性的学习）</li>
<li>主动，深度阅读经典</li>
<li>为那些<code>有趣但非自己关注方向</code>的知识赋予较低的优先级</li>
</ul>
<p>另外，还可以尝试将微信，微博关闭一段时间，或者至少可以不去点那些朋友圈里的<code>《老X聊微服务》</code>或者<code>《12个你不知道的Sublime技巧》</code>文章，保持专注，保持简单。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>不想当UX的开发不是好咨询师</title>
      <link>https://icodeit.org/2016/01/for-those-dev-who-doesnt-want-to-be-a-ux-cannot-be-a-good-consulant/</link>
      <pubDate>Sun, 31 Jan 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/01/for-those-dev-who-doesnt-want-to-be-a-ux-cannot-be-a-good-consulant/</guid>
      <description>成为咨询师 本文旨在帮助开发完成向咨询师的转变，内容不但涉及向UX学习，还包括思维方式的转变。我尽量采用一些亲历的例子来说明该如何做，也会适当的解释为什么需要这样做。不过在展开详细讨论之前，首先来澄清这里提到的三种角色。
开发（Developer）角色 开发是指那些喜欢写代码，享受写代码，喜欢纯粹，讨厌办公室政治，永远穿T恤的有些偏执的程序员。跟他们打交道，有这样一些注意事项：
 不要让他们帮你盗QQ号 不要让他们帮你修电脑或者装Windows系统 不要跟他们讨论人文/政治类的问题  开发往往还单纯的可爱，除此之外，他们还有这样一些特点：
 逻辑清晰 与人争辩时往往可以通过清晰的逻辑而获胜 单身  业界已经有很多关于开发的描述了，我这里也有一个描述开发的列表：
 当然，要严格界定一个人是不是`开发`是非常困难的，大多数情况下，他们沉默寡言，遇到程序中的bug或者在调试某些库的问题时眼神呆滞，口中念念有词，他们不太喜欢和陌生人说话，在晚上精神充沛，白天则显得有些呆滞，喜欢喝咖啡，相信世界上有绝对的正确和错误，往往会带着非黑即白的二分法来看待事物，生活很难自理，喜欢机械键盘/电子设备，周末宁愿宅在家里写代码也不去做社交……  用户体验设计师（UX） UX是指用户体验设计师，在本文的上下文中，更偏向与非视觉设计的那些设计师（产品设计师）。在项目中，他们会做用户调研，竞品分析，信息架构简历，交互设计（纸上原型，低保真）等活动，并负责开发纸上原型，验证这些原型等。
和UX打交道，也有一些应该注意的点，比如：
 不要叫他们美工 不要对他们说诸如：“帮我美化一下这个页面”，“这个颜色得再亮一些”之类的话 不要跟他们讲关于程序员的笑话  事实上，人们对UX的误解很深。提到UX人们的第一反应是PhotoShop，P图/切图。这仅仅是他们日常工作中很小的一部分。大部分UX还要做很多用户研究，信息架构整理的事情。老实说，我在去年5月之前的对UX的认识和大部分开发的认识是一样的，但是在后来的项目上和多个UX合作过之后，我彻底改变了原先那种偏见，开始敬佩他们，并向他们学习。
设计工作可以细分为这样一些不同的方面（图片来源网络）：
UX的一项特别的技能在于能从复杂的现实世界中抽象出清晰的信息（用户画像，体验地图甚至最后的用户故事）。这项技能不但重要，而且还很牛逼。
知识的诅咒 《反脆弱》里有个有意思的例子：人们仅仅创造了非常有限的词汇来描述颜色，比如蓝色，红色，而任何一个视觉正常的人都可以轻松的识别出数百种不同的颜色。也就是说，人们可以很轻松的理解相当复杂的事物，但是很难向别人描述该事物（想象一下向别人描述一只章鱼的颜色）。
人们对于现实世界中的事情（特别是复杂的业务场景）往往只能意会而很难言传，再加上知识的诅咒（我在《如何写一本书》里，详细讨论了这种常见的陷阱）的存在，当用户在描述A的时候，在没有上下文的人听来，很可能是B或者C。这种情况在软件开发中非常常见，也是很多项目之所以延期的原因（大量并无必要的返工，需求澄清等）。
在项目前期，UX需要和客户坐在一起，将客户的需求分析清晰。分析细节包括业务场景，用户画像生成，信息架构，体验地图等等，这些信息并不是天然就显现的，恰恰相反，它们需要UX经过很多轮的辛苦引导，从用户的脑海里提取出来的。
这里需要UX的核心能力是：
 有目的的抛出问题，引导客户进行发散 有节奏的收敛，形成共识 不断修正过程中的错误 可视化能力（这可能是大部分人觉得唯一和UX相关的点）  咨询师 咨询师是指那些根据自己的丰富经验来帮助客户解决具体问题的人。这些问题并不一定局限在技术上 —— 比如架构的设计，具体前端/后端技术的选定，还包括一些流程的改善。比如引入新的工程实践来缩减项目的周期时间，帮助团队发现问题，建设团队的能力，作为各个团队间的润滑剂帮助项目成功等等。
咨询师工作中的一个常见的场景是：
 列出目前遇到的问题 确定各个问题的优先级（和各个利益方） 制定方案 给方案加上时间，形成计划 细化计划中的条目，并促成它  引导/启发 我在印度的某一期TWU当教练的时候，发现了一个很有意思的现象，国外的同事在组织培训时更强调用引导/启发的方式，让学生们自己得出结论，并在课堂上进行讨论，以期教学相长。只有在过程中有启而不发的情况出现时，教练才会适当抛出自己的开发，并再次启动讨论。
与我一直的认识不同的是，这种方式效果很好。通过一些适当的启发，学生很容易自己讨论出一些有趣的看法，然后教练在这个基础上做一些总结，并帮助他们分析不同看法/想法之间的优劣。
我非常认同这种模式，后来自己组织的其他培训/workshop也都尽量采取这种方式。咨询师在客户现场，也应该采取这种引导的方式帮助团队来完成能力建设，而不是事必躬亲。
角色转化 从开发者视角切换到咨询师的第一要诀就是：让团队解决自己遇到的问题！乍听起来，咨询师好像变成一个多余的角色了：既然团队自己可以搞定，还要咨询师干什么呢？咨询师的职责是让团队意识到问题，理清思路，制定解决方案，并逐步实施。
使能/赋能 我们来看一个简单的例子：在客户现场，你发现团队往往在集成时会花费很多额外的时间和返工，开发过程中大家各自为政，没有人知道一次commit会给软件包造成什么影响。
如果你是一个咨询师，应该如何解决这个问题？一个常犯的错误是，直接上手帮助团队搭建持续集成（CI）环境，并设置CI纪律（比如build红了不许过夜，红的时候其他人都不许commit等）。
一种更好的做法是：做为咨询师，首先需要帮助团队认识到这个问题，你需要让所有人都知道，我们现在的问题是什么。在所有人都清楚了这一点之后，你需要提出（或者引导出）持续集成的概念（因为根据经验，这是一种可以很好的解决集成时额外的返工现象的好办法）。
但是对于不熟悉持续集成的团队来说，搭建一个持续集成环境是一个非常复杂的任务。因此你需要分解这个任务为一些更小的，可以被解决的问题。
 申请虚拟机资源 安装jenkins（包括安装JVM，创建用户等） 配置本地构建脚本到jenkins（构建脚本，自动化测试等） 申请显示器资源（作为CI Monitor） 将结果显式在CI Monitor上  有了任务之后，你需要分别为这些子任务分配owner。对比搭建持续集成环境这样的大任务，这些小的任务已经非常具体，更重要的是，他可以被团队中任何人理解并解决。</description>
      <content:encoded><![CDATA[<h2 id="成为咨询师">成为咨询师</h2>
<p>本文旨在帮助<code>开发</code>完成向<code>咨询师</code>的转变，内容不但涉及向<code>UX</code>学习，还包括思维方式的转变。我尽量采用一些亲历的例子来说明该如何做，也会适当的解释为什么需要这样做。不过在展开详细讨论之前，首先来澄清这里提到的三种角色。</p>
<h3 id="开发developer角色">开发（Developer）角色</h3>
<p><code>开发</code>是指那些喜欢写代码，享受写代码，喜欢纯粹，讨厌办公室政治，永远穿T恤的有些偏执的程序员。跟他们打交道，有这样一些注意事项：</p>
<ul>
<li>不要让他们帮你盗<code>QQ</code>号</li>
<li>不要让他们帮你修电脑或者装Windows系统</li>
<li>不要跟他们讨论<code>人文/政治</code>类的问题</li>
</ul>
<p><code>开发</code>往往还单纯的可爱，除此之外，他们还有这样一些特点：</p>
<ul>
<li>逻辑清晰</li>
<li>与人争辩时往往可以通过清晰的逻辑而获胜</li>
<li>单身</li>
</ul>
<p>业界已经有很多关于<code>开发</code>的描述了，我这里也有一个描述<code>开发</code>的列表：</p>
<del>
当然，要严格界定一个人是不是`开发`是非常困难的，大多数情况下，他们沉默寡言，遇到程序中的bug或者在调试某些库的问题时眼神呆滞，口中念念有词，他们不太喜欢和陌生人说话，在晚上精神充沛，白天则显得有些呆滞，喜欢喝咖啡，相信世界上有绝对的正确和错误，往往会带着非黑即白的二分法来看待事物，生活很难自理，喜欢机械键盘/电子设备，周末宁愿宅在家里写代码也不去做社交……
</del>
<h3 id="用户体验设计师ux">用户体验设计师（UX）</h3>
<p><code>UX</code>是指用户体验设计师，在本文的上下文中，更偏向与非<code>视觉设计</code>的那些设计师（产品设计师）。在项目中，他们会做用户调研，竞品分析，信息架构简历，交互设计（纸上原型，低保真）等活动，并负责开发纸上原型，验证这些原型等。</p>
<p>和<code>UX</code>打交道，也有一些应该注意的点，比如：</p>
<ul>
<li>不要叫他们美工</li>
<li>不要对他们说诸如：“帮我美化一下这个页面”，“这个颜色得再亮一些”之类的话</li>
<li>不要跟他们讲关于程序员的笑话</li>
</ul>
<p>事实上，人们对<code>UX</code>的误解很深。提到<code>UX</code>人们的第一反应是<code>PhotoShop</code>，P图/切图。这仅仅是他们日常工作中很小的一部分。大部分<code>UX</code>还要做很多用户研究，信息架构整理的事情。老实说，我在去年5月之前的对<code>UX</code>的认识和大部分<code>开发</code>的认识是一样的，但是在后来的项目上和多个<code>UX</code>合作过之后，我彻底改变了原先那种偏见，开始敬佩他们，并向他们学习。</p>
<p>设计工作可以细分为这样一些不同的方面（图片来源网络）：</p>
<p><img loading="lazy" src="/images/2016/01/jjg-resized.png" type="" alt="JJG"  /></p>
<p><code>UX</code>的一项特别的技能在于能从复杂的现实世界中抽象出清晰的信息（用户画像，体验地图甚至最后的用户故事）。这项技能不但重要，而且还很牛逼。</p>
<h4 id="知识的诅咒">知识的诅咒</h4>
<p><a href="https://book.douban.com/subject/25782902/">《反脆弱》</a>里有个有意思的例子：人们仅仅创造了非常有限的词汇来描述颜色，比如蓝色，红色，而任何一个视觉正常的人都可以轻松的识别出数百种不同的颜色。也就是说，人们可以很轻松的理解相当复杂的事物，但是很难向别人描述该事物（想象一下向别人描述一只<code>章鱼</code>的颜色）。</p>
<p>人们对于现实世界中的事情（特别是复杂的业务场景）往往只能意会而很难言传，再加上知识的诅咒（我在<a href="http://icodeit.org/2015/08/how-to-write-a-book/">《如何写一本书》</a>里，详细讨论了这种常见的陷阱）的存在，当用户在描述A的时候，在没有上下文的人听来，很可能是B或者C。这种情况在软件开发中非常常见，也是很多项目之所以延期的原因（大量并无必要的返工，需求澄清等）。</p>
<p>在项目前期，<code>UX</code>需要和客户坐在一起，将客户的需求分析清晰。分析细节包括业务场景，用户画像生成，信息架构，体验地图等等，这些信息并不是天然就显现的，恰恰相反，它们需要UX经过很多轮的辛苦引导，从用户的脑海里<code>提取</code>出来的。</p>
<p>这里需要<code>UX</code>的核心能力是：</p>
<ul>
<li>有目的的抛出问题，引导客户进行发散</li>
<li>有节奏的收敛，形成共识</li>
<li>不断修正过程中的错误</li>
<li>可视化能力（这可能是大部分人觉得唯一和UX相关的点）</li>
</ul>
<h3 id="咨询师">咨询师</h3>
<p><code>咨询师</code>是指那些根据自己的丰富经验来帮助客户解决具体问题的人。这些问题并不一定局限在技术上 —— 比如架构的设计，具体前端/后端技术的选定，还包括一些流程的改善。比如引入新的<code>工程实践</code>来缩减项目的周期时间，帮助团队发现问题，建设团队的能力，作为各个团队间的润滑剂帮助项目成功等等。</p>
<p><code>咨询师</code>工作中的一个常见的场景是：</p>
<ul>
<li>列出目前遇到的问题</li>
<li>确定各个问题的优先级（和各个利益方）</li>
<li>制定方案</li>
<li>给方案加上时间，形成计划</li>
<li>细化计划中的条目，并促成它</li>
</ul>
<h4 id="引导启发">引导/启发</h4>
<p>我在印度的某一期<code>TWU</code>当教练的时候，发现了一个很有意思的现象，国外的同事在组织培训时更强调用<code>引导</code>/<code>启发</code>的方式，让学生们自己得出结论，并在课堂上进行讨论，以期教学相长。只有在过程中有<code>启而不发</code>的情况出现时，教练才会适当抛出自己的开发，并再次启动讨论。</p>
<p><img loading="lazy" src="/images/2016/01/twu22-resized.png" type="" alt="TWU 33"  /></p>
<p>与我一直的认识不同的是，这种方式效果很好。通过一些适当的启发，学生很容易自己讨论出一些有趣的看法，然后教练在这个基础上做一些总结，并帮助他们分析不同看法/想法之间的优劣。</p>
<p>我非常认同这种模式，后来自己组织的其他培训/workshop也都尽量采取这种方式。咨询师在客户现场，也应该采取这种<code>引导</code>的方式帮助团队来完成能力建设，而不是事必躬亲。</p>
<h2 id="角色转化">角色转化</h2>
<p>从<code>开发者</code>视角切换到<code>咨询师</code>的第一要诀就是：让团队解决自己遇到的问题！乍听起来，<code>咨询师</code>好像变成一个多余的角色了：既然团队自己可以搞定，还要<code>咨询师</code>干什么呢？<code>咨询师</code>的职责是让团队意识到问题，理清思路，制定解决方案，并逐步实施。</p>
<h3 id="使能赋能">使能/赋能</h3>
<p>我们来看一个简单的例子：在客户现场，你发现团队往往在集成时会花费很多额外的时间和返工，开发过程中大家各自为政，没有人知道一次commit会给软件包造成什么影响。</p>
<p>如果你是一个<code>咨询师</code>，应该如何解决这个问题？一个常犯的错误是，直接上手帮助团队搭建<a href="http://www.martinfowler.com/articles/continuousIntegration.html">持续集成</a>（CI）环境，并设置CI纪律（比如build红了不许过夜，红的时候其他人都不许commit等）。</p>
<p>一种更好的做法是：做为<code>咨询师</code>，首先需要帮助团队认识到这个问题，你需要让所有人都知道，我们现在的问题是什么。在所有人都清楚了这一点之后，你需要提出（或者<code>引导</code>出）持续集成的概念（因为根据经验，这是一种可以很好的解决集成时额外的返工现象的好办法）。</p>
<p>但是对于不熟悉<code>持续集成</code>的团队来说，搭建一个持续集成环境是一个非常<code>复杂</code>的任务。因此你需要分解这个任务为一些更小的，可以被解决的问题。</p>
<ul>
<li>申请虚拟机资源</li>
<li>安装<a href="https://jenkins-ci.org/">jenkins</a>（包括安装JVM，创建用户等）</li>
<li>配置本地构建脚本到jenkins（构建脚本，自动化测试等）</li>
<li>申请显示器资源（作为CI Monitor）</li>
<li>将结果显式在CI Monitor上</li>
</ul>
<p>有了任务之后，你需要分别为这些子任务分配owner。对比搭建<code>持续集成环境</code>这样的大任务，这些小的任务已经非常具体，更重要的是，他可以被团队中任何人理解并解决。</p>
<h3 id="学习做引导">学习做引导</h3>
<p>除了思维方式的转变，以及自身过硬的专业技能（比如clean code/重构能力，自动化测试，DevOps，持续交付经验等）之外，开发者需要从<code>UX</code>那里学习如何发现问题，并将问题可视化出来的技能。</p>
<p>当你发现团队面临某个问题是，可以通过组织一个类似<code>头脑风暴</code>的会议来帮助团队梳理：</p>
<ul>
<li>提出问题</li>
<li>维护会议纪律，保证所有人都贡献自己的想法</li>
<li>将想法/问题归类</li>
<li>找出问题的解决方案</li>
<li>制定计划（包括时间点和owner）</li>
</ul>
<p>关于如何做引导的详细信息，还可以参考我的<a href="http://icodeit.org/2016/01/how-to-facilitate/">上一篇文章</a>。</p>
<h3 id="进一步的阅读">进一步的阅读</h3>
<p>除了上边提到的</p>
<ol>
<li>思维方式的转变</li>
<li>向<code>UX</code>学习引导的技巧</li>
</ol>
<p>之外，事实上还有很多技巧和内容需要学习：</p>
<ul>
<li><a href="https://book.douban.com/subject/25899338/">《引导的秘诀》</a></li>
<li><a href="https://book.douban.com/subject/10433731/">《视觉会议》</a></li>
<li><a href="https://book.douban.com/subject/4051739/">《第五项修炼》</a></li>
<li><a href="https://book.douban.com/subject/1156866/">《系统思考》</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>如何正确的引导会议</title>
      <link>https://icodeit.org/2016/01/how-to-facilitate/</link>
      <pubDate>Sat, 23 Jan 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/01/how-to-facilitate/</guid>
      <description>什么是引导（facilitation） 引导（facilitation）的词根来源与拉丁语“facil”，意思是“让……更容易”。而负责引导的引导师（facilitator）的核心职责是，通过一系列的活动、技巧，保证引导会议顺畅的进行，并解决整个过程中的问题，使得参与者就问题产生一个共识，达成一个结论。
其中可能涉及很多具体的问题，比如几乎在每个会议中都可能看到的：
 如果有人尝试将会议变成一言堂，如何处理？ 如果参与者不愿意分享自己的观点，如何处理？ 过程中，两个参与者产生了争执，如何处理？ 如何把握节奏，刺激与会者发散？ 如何在收集到足够信息后，进行收敛？  显然，这是一个技术活儿。一次好的引导可以将与会者的众多想法，信息聚合起来，形成对团队下一步要做什么有极强指导意义的方案。
日常的引导活动 在平时的工作中，我们其实已经在频繁的使用引导活动，但是很少有人将其作为体系来关注，也很少有人能将这个能力应用在其他方面（比如在客户现场咨询，或者参加售前等）。引导是如此的常见，以至于我们对其视而不见。比如在interview完成之后，所有面试官和HR一起做的well/less well的列举；各种社区活动（Open Party，CDConf等）之后的回顾；每个项目在一个迭代结束后的Retro；对于某个问题的头脑风暴等等。
项目回顾会议 在开始前，引导师需要保证团队：
 每个人都有开发的态度 整个过程需要在一个足够安全的环境中进行（Safe Check）  有时候，有Team Lead在场，新人可能不愿意对某事（比如最近加班有点过分）发表自己的看法等。这时候需要有Safe Check，比如分为1到5档，大家用不记名投票的方式来表述自己是否觉得安全。如果投票结果显示大部分人都觉得不安全，则需要与会的人中，职位最高的那个人离开会议，然后再做一次Safe Check，直到大家都觉得足够安全。不过，对于已经进行过多轮回顾的团队，我们往往会忽略掉这一步。
Retro过程是，团队坐在一起，回顾上一个迭代（通常是两个星期）做过的事情，有哪些做的比较好，哪些有待改进，有哪些疑惑等等。Retro可以有很多的形式，比如简单的Well/Less Well/Questions，更聚焦在产生Action的海星式等等。
通常的顺序是：
 引导者请大家用纸笔将想法写在便签（stick）上 Time box这个过程（通常是5分钟） 大家将这些stick贴在墙上 引导者和团队一起过一遍所有的stick 归类相似的stick 引导者促进团队交流，讨论stick上的问题，并形成一些改进点（Action）  Action一定要足够具体，并且需要一个所有者，所有者负责确保该Action一定会发生。比如团队发现上一个迭代中Code review做的不够好，一个Action就是每天下午5点有人来提醒大家来进行Code review。
如果这时候发现有太多的问题，团队可以用投票的方式选出本次Retro要讨论的数个stick。
引导会议 在日常工作中，我们几乎每天都有会议，而且越来越多的团队已经意识到冗长，无聊的会议有多大的杀伤力了。在很多会议上，与会者要么在刷新朋友圈，要么在对着笔记本电脑写代码或者读新闻，即使强制要求不许带电脑和手机的情况下，也无法限制参加者神游太虚。
根据《引导的秘诀》这本书里的定义，引导会议是
引导会议是一个高度结构化的会议，会议中的领导者（引导者）引导参会人通过预先设定好的步骤达成所有参会人产生，理解并接受的结果。  引导会议需要充分调用参与者的积极性，每个人都需要足够聚焦，这要求引导者可以有能力使得团队振奋（比如幽默的风格，或者具有挑战性的问题等）。另外，每个人的idea都需要被充分重视（一个细节就是不要随意篡改你听到的内容，这是没有经验的引导者常犯的错误之一）。一旦所有参与者都积极起来，引导者就可以稍微退后一些，将舞台交给团队。
而有时候，情景则相反，大家都不发言，也没有看到明显的发言的趋势，这时候需要一些方法来激励。如果是团队都比较茫然，引导者需要列出一些简单而容易理解的步骤，帮助团队按照预设的节奏来逐步前进。比如，在一开始的时候就将agenda板书在墙上，并通过头脑风暴的方式，鼓励参与者来将自己的idea可视化出来。
一个典型的误区是，引导会议的最后结论是本来就存在与引导者脑海中的想法。如果仅从结果来看，这种情况可能发生，但是只能说是碰巧而已。一个好的引导者需要帮助与会者自己产生，并得出一个可行的，被广泛认可的方案，而不是强加一个自己的给团队。
我们最为专业的引导活动是UX团队在客户现场的inception，inception由一系列相互关联，环环相扣的工作坊组成，这些工作坊基本上都需要采用很多引导的技巧，帮助客户团队将自己的问题描述清楚，并形成一个所有参与者都达成一直的可行方案。
如果你不知道如何开始一个引导会议，一个简单而通用的模式是：
 我们的现状是 我们的目标是 我们如何到达目标 在行进中，如何度量  《引导的秘诀》里还提到了一种5P模式：目的(Purpose)，产出(Product)，与会人(Participant)，可能的问题(Probable issues)以及流程(Process)。
5P提示你在准备会议之前，需要尝试回答这几个问题
 为什么要开这次会议？主要目的是什么？ 会议后的产出是什么？ 谁需要参与会议？ 在会议中，我们可能遇到什么问题？ 遇到这些问题是，我们如何解决？  引导中的常用技巧 在引导活动中，有一些基本的规则，可以保证引导会议的顺畅性，比如</description>
      <content:encoded><![CDATA[<h2 id="什么是引导facilitation">什么是引导（facilitation）</h2>
<p>引导（facilitation）的词根来源与拉丁语“facil”，意思是“让……更容易”。而负责引导的<code>引导师</code>（facilitator）的核心职责是，通过一系列的活动、技巧，保证引导会议顺畅的进行，并解决整个过程中的问题，使得参与者就问题产生一个共识，达成一个结论。</p>
<p>其中可能涉及很多具体的问题，比如几乎在每个会议中都可能看到的：</p>
<ul>
<li>如果有人尝试将会议变成一言堂，如何处理？</li>
<li>如果参与者不愿意分享自己的观点，如何处理？</li>
<li>过程中，两个参与者产生了争执，如何处理？</li>
<li>如何把握节奏，刺激与会者发散？</li>
<li>如何在收集到足够信息后，进行收敛？</li>
</ul>
<p>显然，这是一个技术活儿。一次好的引导可以将与会者的众多想法，信息聚合起来，形成对团队下一步要做什么有极强指导意义的<code>方案</code>。</p>
<h2 id="日常的引导活动">日常的引导活动</h2>
<p>在平时的工作中，我们其实已经在频繁的使用引导活动，但是很少有人将其作为体系来关注，也很少有人能将这个能力应用在其他方面（比如在客户现场咨询，或者参加售前等）。引导是如此的常见，以至于我们对其视而不见。比如在interview完成之后，所有面试官和HR一起做的well/less well的列举；各种社区活动（Open Party，CDConf等）之后的回顾；每个项目在一个迭代结束后的Retro；对于某个问题的头脑风暴等等。</p>
<h3 id="项目回顾会议">项目回顾会议</h3>
<p>在开始前，引导师需要保证团队：</p>
<ul>
<li>每个人都有开发的态度</li>
<li>整个过程需要在一个足够安全的环境中进行（Safe Check）</li>
</ul>
<p>有时候，有Team Lead在场，新人可能不愿意对某事（比如最近加班有点过分）发表自己的看法等。这时候需要有<code>Safe Check</code>，比如分为1到5档，大家用不记名投票的方式来表述自己是否觉得安全。如果投票结果显示大部分人都觉得不安全，则需要与会的人中，职位最高的那个人离开会议，然后再做一次<code>Safe Check</code>，直到大家都觉得足够安全。不过，对于已经进行过多轮回顾的团队，我们往往会忽略掉这一步。</p>
<p>Retro过程是，团队坐在一起，回顾上一个迭代（通常是两个星期）做过的事情，有哪些做的比较好，哪些有待改进，有哪些疑惑等等。Retro可以有很多的形式，比如简单的<code>Well/Less Well/Questions</code>，更聚焦在产生<code>Action</code>的海星式等等。</p>
<p><img loading="lazy" src="/images/2016/01/pens-resized.png" type="" alt="pens"  /></p>
<p>通常的顺序是：</p>
<ol>
<li>引导者请大家用纸笔将想法写在便签（stick）上</li>
<li>Time box这个过程（通常是5分钟）</li>
<li>大家将这些stick贴在墙上</li>
<li>引导者和团队一起过一遍所有的stick</li>
<li>归类相似的stick</li>
<li>引导者促进团队交流，讨论stick上的问题，并形成一些改进点（Action）</li>
</ol>
<p>Action一定要足够具体，并且需要一个所有者，<code>所有者</code>负责确保该<code>Action</code>一定会发生。比如团队发现上一个迭代中<code>Code review</code>做的不够好，一个<code>Action</code>就是每天下午5点有人来提醒大家来进行<code>Code review</code>。</p>
<p>如果这时候发现有太多的问题，团队可以用投票的方式选出本次Retro要讨论的数个stick。</p>
<h3 id="引导会议">引导会议</h3>
<p>在日常工作中，我们几乎每天都有会议，而且越来越多的团队已经意识到冗长，无聊的会议有多大的杀伤力了。在很多会议上，与会者要么在刷新朋友圈，要么在对着笔记本电脑写代码或者读新闻，即使强制要求不许带电脑和手机的情况下，也无法限制参加者神游太虚。</p>
<p>根据《引导的秘诀》这本书里的定义，引导会议是</p>
<pre><code>引导会议是一个高度结构化的会议，会议中的领导者（引导者）引导参会人通过预先设定好的步骤达成所有参会人产生，理解并接受的结果。
</code></pre>
<p>引导会议需要充分调用参与者的积极性，每个人都需要足够聚焦，这要求引导者可以有能力使得团队振奋（比如幽默的风格，或者具有挑战性的问题等）。另外，每个人的idea都需要被充分重视（一个细节就是不要随意篡改你听到的内容，这是没有经验的引导者常犯的错误之一）。一旦所有参与者都积极起来，引导者就可以稍微退后一些，将舞台交给团队。</p>
<p>而有时候，情景则相反，大家都不发言，也没有看到明显的发言的趋势，这时候需要一些方法来激励。如果是团队都比较茫然，引导者需要列出一些简单而容易理解的步骤，帮助团队按照预设的节奏来逐步前进。比如，在一开始的时候就将agenda板书在墙上，并通过头脑风暴的方式，鼓励参与者来将自己的idea可视化出来。</p>
<p>一个典型的误区是，引导会议的最后结论是本来就存在与引导者脑海中的想法。如果仅从结果来看，这种情况可能发生，但是只能说是碰巧而已。一个好的引导者需要帮助与会者自己产生，并得出一个可行的，被广泛认可的方案，而不是强加一个自己的给团队。</p>
<p>我们最为专业的引导活动是UX团队在客户现场的<code>inception</code>，<code>inception</code>由一系列相互关联，环环相扣的工作坊组成，这些工作坊基本上都需要采用很多引导的技巧，帮助客户团队将自己的问题描述清楚，并形成一个所有参与者都达成一直的可行方案。</p>
<p><img loading="lazy" src="/images/2016/01/sticks-resized.png" type="" alt="sticks"  /></p>
<p>如果你不知道如何开始一个引导会议，一个简单而通用的模式是：</p>
<ol>
<li>我们的现状是</li>
<li>我们的目标是</li>
<li>我们如何到达目标</li>
<li>在行进中，如何度量</li>
</ol>
<p>《引导的秘诀》里还提到了一种<code>5P</code>模式：目的(Purpose)，产出(Product)，与会人(Participant)，可能的问题(Probable issues)以及流程(Process)。</p>
<p>5P提示你在准备会议之前，需要尝试回答这几个问题</p>
<ul>
<li>为什么要开这次会议？主要目的是什么？</li>
<li>会议后的产出是什么？</li>
<li>谁需要参与会议？</li>
<li>在会议中，我们可能遇到什么问题？</li>
<li>遇到这些问题是，我们如何解决？</li>
</ul>
<h2 id="引导中的常用技巧">引导中的常用技巧</h2>
<p>在引导活动中，有一些基本的规则，可以保证引导会议的顺畅性，比如</p>
<ul>
<li>引导师需要有足够的权威（可以打断那些长篇大论，保证过程的流畅）</li>
<li>如果人数太多，可以使用token（比如一个玩具考拉，或者一个澳式橄榄球，只有持有token的人可以说话）</li>
<li>保持one conversation（不要交头接耳）</li>
<li>每张stick上只写一条问题/想法</li>
</ul>
<p>引导师必须有控制会话何时结束的能力，否则引导活动将会变成一发不可收拾的冗长会议。坚持<code>one conversation</code>可以保证参与者足够聚焦，也保证所有人都在同一个频道上。如果发现有交头接耳的，引导者可以直接打断并提醒之。</p>
<p>每张便签上只写一条想法，首先可以保证多样性，便于讨论，也便于后续的分类。另外，简洁的描述在一定程度上可以促进与会者进行讨论，而一个冗长的描述则会让人丧失兴趣。</p>
<p>另外还有一些比较基础的技巧：</p>
<ul>
<li>所有讨论都应该对事不对人（特别是一些负面的总结）</li>
<li>如果有人提出与议题并不特别相关，但是又特别重要的点时，可以将这些点记下来（不要轻易打击发言者的积极性）</li>
<li>不定时的总结，以确保参与者都在同一频道，并且有助于大家对进度的了解（是不是快结束了）</li>
</ul>
]]></content:encoded>
    </item>
    
    <item>
      <title>穷人的持续交付 - 下</title>
      <link>https://icodeit.org/2016/01/a-poor-mans-cd-part2/</link>
      <pubDate>Sun, 10 Jan 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/01/a-poor-mans-cd-part2/</guid>
      <description>本文将使用一些免费的服务来为你的项目搭建`持续交付`平台，这些服务包括,持续集成环境,持续部署环境和服务端应用托管</description>
      <content:encoded><![CDATA[<h1 id="客户端程序的的持续交付">客户端程序的的持续交付</h1>
<p><a href="http://icodeit.org/2016/01/a-poor-mans-cd-part1/">上篇文章</a>介绍了如何使用一些免费的服务来实现服务器端API的持续集成、持续交付环境的搭建。有了服务端，自然需要有消费者，在本文中我们将使用另外一个工具来实现纯前端的站点的部署。</p>
<p>其中包括：</p>
<ul>
<li>持续集成（单元测试，集成测试等）</li>
<li>持续部署/持续交付</li>
<li>静态站点托管</li>
</ul>
<p>除此之外，我们还会涉及到：</p>
<ul>
<li><a href="https://github.com/natritmeyer/site_prism">自动化UI测试site_prism</a></li>
<li>静态站点的发布脚本</li>
<li>aws的<a href="http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html">命令行工具</a></li>
</ul>
<p>我们的应用最后看起来是这样子的。</p>
<p><img loading="lazy" src="/images/2016/01/bookmarks-app-resized.png" type="" alt="bookmarks app"  /></p>
<h2 id="技术选型">技术选型</h2>
<p>我们在本文中，将采取另外一套免费服务来完成环境的搭建</p>
<ul>
<li><a href="http://www.thoughtworks.com/">ThoughtWorks</a>出品的<a href="https://snap-ci.com/">Snap CI</a>作为持续集成/持续交付环境</li>
<li><a href="https://console.aws.amazon.com/s3/home?region=us-west-2">AWS的S3</a>作为应用发布的地方</li>
</ul>
<p><code>Snap CI</code>是一个非常易于使用的持续交付环境，由于很多关于持续集成，持续交付的概念和实践都跟<code>ThoughtWorks</code>有关，所以这个产品对于构建，流水线，部署等等的支持也都做的非常好。</p>
<p><code>S3</code>是亚马逊的云存储平台，我们可以将静态资源完全托管在其上。<code>S3</code>的另一个好处是它可以将你的文件变成一个Web Site，比如你的目录中有<code>index.html</code>，这个文件就可以作为你的站点首页被其他人访问。这个对于我们这个前后端分离项目来说非常有用，我们的<code>css</code>，<code>js</code>，<code>font</code>文件，还有入口文件<code>index.html</code>都可以托管于其上。</p>
<h2 id="实例">实例</h2>
<p>在本文的例子中，我们将定义3个<code>stage</code>。<code>Snap CI</code>将一次发布分为若干个<code>stage</code>，每个<code>stage</code>只做一件事情，如果一个<code>stage</code>失败了，后边的就不会接着执行。</p>
<p>我们的3个<code>stage</code>分别为：</p>
<ol>
<li>单元测试</li>
<li>集成测试</li>
<li>部署</li>
</ol>
<h3 id="准备工作">准备工作</h3>
<p><code>bookmarks-frontend</code>是一个纯前端的应用，它会消费后端提供的API，但是其实它并不知道（也不应该知道）后端的API部署在什么地方：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js">
<span class="nx">$</span><span class="p">(</span><span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">feeds</span> <span class="o">=</span> <span class="nx">$</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="nx">config</span><span class="p">.</span><span class="nx">backend</span><span class="o">+</span><span class="s1">&#39;/api/feeds&#39;</span><span class="p">);</span>
	<span class="kd">var</span> <span class="nx">favorite</span> <span class="o">=</span> <span class="nx">$</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="nx">config</span><span class="p">.</span><span class="nx">backend</span><span class="o">+</span><span class="s1">&#39;/api/fav-feeds/1&#39;</span><span class="p">);</span>

	<span class="nx">$</span><span class="p">.</span><span class="nx">when</span><span class="p">(</span><span class="nx">feeds</span><span class="p">,</span> <span class="nx">favorite</span><span class="p">).</span><span class="nx">then</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">feeds</span><span class="p">,</span> <span class="nx">favorite</span><span class="p">)</span> <span class="p">{</span>
		<span class="c1">//...
</span><span class="c1"></span>	<span class="p">});</span>
<span class="p">});</span>
</code></pre></div><p>由于我们在本地开发时，需要<code>backend</code>指向本地的服务器，而发布之后，则希望它指向<a href="http://icodeit.org/2016/01/a-poor-mans-cd-part1/">上一篇文章</a>中提到的服务器，因此我们需要编写一点构建脚本来完成这件事儿：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">var</span> <span class="nx">backend</span> <span class="o">=</span> <span class="s1">&#39;http://quiet-atoll-8237.herokuapp.com&#39;</span><span class="p">;</span>

<span class="nx">gulp</span><span class="p">.</span><span class="nx">task</span><span class="p">(</span><span class="s1">&#39;prepareConfig&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
    <span class="nx">gulp</span><span class="p">.</span><span class="nx">src</span><span class="p">([</span><span class="s1">&#39;assets/templates/config.js&#39;</span><span class="p">])</span>
    <span class="p">.</span><span class="nx">pipe</span><span class="p">(</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/#backend#/g</span><span class="p">,</span> <span class="s1">&#39;http://localhost:8100&#39;</span><span class="p">))</span>
    <span class="p">.</span><span class="nx">pipe</span><span class="p">(</span><span class="nx">gulp</span><span class="p">.</span><span class="nx">dest</span><span class="p">(</span><span class="s1">&#39;assets/script/&#39;</span><span class="p">));</span>
<span class="p">});</span>

<span class="nx">gulp</span><span class="p">.</span><span class="nx">task</span><span class="p">(</span><span class="s1">&#39;prepareRelease&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
    <span class="nx">gulp</span><span class="p">.</span><span class="nx">src</span><span class="p">([</span><span class="s1">&#39;assets/templates/config.js&#39;</span><span class="p">])</span>
    <span class="p">.</span><span class="nx">pipe</span><span class="p">(</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/#backend#/g</span><span class="p">,</span> <span class="nx">backend</span><span class="p">))</span>
    <span class="p">.</span><span class="nx">pipe</span><span class="p">(</span><span class="nx">gulp</span><span class="p">.</span><span class="nx">dest</span><span class="p">(</span><span class="s1">&#39;assets/script/&#39;</span><span class="p">));</span>
<span class="p">});</span>
</code></pre></div><p>我们定义了两个<code>gulp</code>的task，本地开发时，使用<code>prepareConfig</code>，要发布时，使用<code>prepareRelease</code>，然后定义一个简单的模板文件<code>config.js</code>：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="p">{</span>
	<span class="nx">backend</span><span class="o">:</span> <span class="s1">&#39;#backend#&#39;</span>
<span class="p">}</span>
</code></pre></div><p>然后可以很简单的包装一下，方便本地开发和发布：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">gulp</span><span class="p">.</span><span class="nx">task</span><span class="p">(</span><span class="s1">&#39;dev&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;prepareConfig&#39;</span><span class="p">,</span> <span class="s1">&#39;browserify&#39;</span><span class="p">,</span> <span class="s1">&#39;concatcss&#39;</span><span class="p">]);</span>
<span class="nx">gulp</span><span class="p">.</span><span class="nx">task</span><span class="p">(</span><span class="s1">&#39;build&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;prepareConfig&#39;</span><span class="p">,</span> <span class="s1">&#39;script&#39;</span><span class="p">,</span> <span class="s1">&#39;css&#39;</span><span class="p">]);</span>
<span class="nx">gulp</span><span class="p">.</span><span class="nx">task</span><span class="p">(</span><span class="s1">&#39;release&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;prepareRelease&#39;</span><span class="p">,</span> <span class="s1">&#39;script&#39;</span><span class="p">,</span> <span class="s1">&#39;css&#39;</span><span class="p">]);</span>
</code></pre></div><p>这样，我们在本地开发时，只需要简单的执行：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ gulp
</code></pre></div><p>即可。而在发布阶段，只需要执行：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ gulp release
</code></pre></div><h3 id="单元测试">单元测试</h3>
<p>我们在<code>Snap CI</code>上将<code>github</code>上的代码库关联起来，然后添加一个名叫<code>unit-test</code>的<code>stage</code>，指定这个<code>stage</code>对应的命令为：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">npm install
gulp
</code></pre></div><p><img loading="lazy" src="/images/2016/01/snap-ci-unit-resized.png" type="" alt="Snap CI unit"  /></p>
<p>这样，每当我们有新的提交之后，<code>Snap CI</code>都会拿到新代码，并执行上述命令，如果执行成功，则本地构建成功。</p>
<h3 id="集成测试">集成测试</h3>
<p>由于采取的是<strong>前后端分离</strong>的策略，我们的应用可以完全独立与后端进行开发，因此我们设置了一个<code>fake server</code>，具体细节可以参考<a href="http://icodeit.org/2015/06/whats-next-after-separate-frontend-and-backend/">我之前的博客</a>，也可以看源码。不过这里我们要为集成测试编写一个脚本，并在<code>Snap CI</code>上执行。</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh"><span class="cp">#!/bin/bash
</span><span class="cp"></span>
<span class="nb">export</span> <span class="nv">PORT</span><span class="o">=</span><span class="m">8100</span>
bundle install

<span class="c1"># launch the application</span>
<span class="nb">echo</span> <span class="s2">&#34;launch the application&#34;</span>
ruby app.rb 2&gt;<span class="p">&amp;</span><span class="m">1</span> <span class="p">&amp;</span>
<span class="nv">PID</span><span class="o">=</span><span class="nv">$!</span>

<span class="c1"># wait for it to start up</span>
sleep <span class="m">3</span>

<span class="c1"># run the rspec tests and record the status</span>
rspec
<span class="nv">RES</span><span class="o">=</span><span class="nv">$?</span>

<span class="c1"># terminate after rspec</span>
<span class="nb">echo</span> <span class="s2">&#34;terminate the application&#34;</span>
<span class="nb">kill</span> -9 <span class="nv">$PID</span>

<span class="c1"># now we know whether the rspec success or not</span>
<span class="nb">exit</span> <span class="nv">$RES</span>
</code></pre></div><p>这个脚本中，首先安装所有的<code>gems</code>，然后启动<code>fake server</code>并将这个server放置在后台运行，然后执行<code>rspec</code>。当<code>rspec</code>测试执行完成之后，我们终止服务进行，然后返回结果状态码。</p>
<p>这里使用了<code>capybara</code>和<code>poltergeist</code>来做UI测试，<code>capybara</code>会驱动<code>phantomjs</code>来在内存中运行浏览器，并执行定义好的<code>UI</code>测试，比如此处，我们的UI测试：</p>
<div class="highlight"><pre class="chroma"><code class="language-rb" data-lang="rb"><span class="nb">require</span> <span class="s1">&#39;spec_helper&#39;</span>

<span class="n">describe</span> <span class="s1">&#39;Feeds List Page&#39;</span> <span class="k">do</span>
	<span class="n">let</span><span class="p">(</span><span class="ss">:list_page</span><span class="p">)</span> <span class="p">{</span><span class="no">FeedListPage</span><span class="o">.</span><span class="n">new</span><span class="p">}</span>

	<span class="n">before</span> <span class="k">do</span>
		<span class="n">list_page</span><span class="o">.</span><span class="n">load</span>
	<span class="k">end</span>

	<span class="n">it</span> <span class="s1">&#39;user can see a banner and some feeds&#39;</span> <span class="k">do</span>
		<span class="n">expect</span><span class="p">(</span><span class="n">list_page</span><span class="p">)</span><span class="o">.</span><span class="n">to</span> <span class="n">have_banner</span>
		<span class="n">expect</span><span class="p">(</span><span class="n">list_page</span><span class="p">)</span><span class="o">.</span><span class="n">to</span> <span class="n">have_feeds</span>
	<span class="k">end</span>
	
	<span class="c1">##...</span>
<span class="k">end</span>
</code></pre></div><p><img loading="lazy" src="/images/2016/01/snap-ci-it-resized.png" type="" alt="Snap CI logs"  /></p>
<h3 id="部署">部署</h3>
<p>首先需要在<code>S3</code>上创建一个<code>bucket</code>，命名为<code>bookmarks-frontend</code>。然后为其设置<code>static website hosting</code>，这时候<code>AWS</code>会assign一个新的域名给你，比如<code>http://bookmarks-frontend.s3-website-us-west-2.amazonaws.com/</code>。</p>
<p>然后你需要将这个<code>bucket</code>设置成<code>public</code>，这样其他人才可以访问你的<code>bucket</code>。</p>
<p><img loading="lazy" src="/images/2016/01/aws-s3-public-resized.png" type="" alt="AWS S3"  /></p>
<p>有了这个之后，我们来编写一个小脚本，这个脚本可以将本地的文件上传至S3。</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh"><span class="cp">#!/bin/bash
</span><span class="cp"></span>
<span class="c1"># install gulp and its dependencies</span>
npm install

<span class="c1"># package stuff, and point the server to the right place</span>
gulp release

<span class="c1"># upload the whold folder</span>
aws s3 cp public/ s3://bookmarks-frontend <span class="se">\
</span><span class="se"></span>	--recursive <span class="se">\
</span><span class="se"></span>	--region us-west-2 <span class="se">\
</span><span class="se"></span>	--acl public-read
</code></pre></div><p><code>aws</code>命令是<code>aws command line</code>提供的，另外我们需要在环境变量中设置AWS提供给你的token：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh"><span class="nv">AWS_ACCESS_KEY_ID</span><span class="o">=</span>xxxxxxxxxx
<span class="nv">AWS_SECRET_ACCESS_KEY</span><span class="o">=</span>xxxxxxxxxx
</code></pre></div><p>然后我们就可以将本地的<code>public</code>目录递归的上传到S3的对应目录了！</p>
<p><img loading="lazy" src="/images/2016/01/snap-ci-pipeline-resized.png" type="" alt="snap ci pipeline"  /></p>
<p>完整的代码可以在<a href="https://github.com/abruzzi/bookmarks-frontend">此处下载</a>。</p>
<h2 id="总结">总结</h2>
<p>我们前端的持续交付也介绍完了。现在前后端应用完全独立，发布也互不影响。不论是服务器端新增加了API，还是添加了新数据，客户端的发布都不受影响；同样，修改样式，添加新的<code>JavaScript</code>也完全不会影响后端。更重要的是，所有的发布都是一键式的，开发者只需要一个<code>git push</code>就可以享受这些免费服务提供的自动构建，自动化测试以及自动部署的功能。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>穷人的持续交付 - 上</title>
      <link>https://icodeit.org/2016/01/a-poor-mans-cd-part1/</link>
      <pubDate>Sat, 09 Jan 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/01/a-poor-mans-cd-part1/</guid>
      <description>本文将使用一些免费的服务来为你的项目搭建`持续交付`平台，这些服务包括,持续集成环境,持续部署环境和服务端应用托管</description>
      <content:encoded><![CDATA[<h1 id="服务器端应用的持续交付">服务器端应用的持续交付</h1>
<p>本文将使用一些免费的服务来为你的项目搭建<code>持续交付</code>平台，这些服务包括</p>
<ul>
<li>持续集成环境</li>
<li>持续部署环境</li>
<li>服务端应用托管</li>
</ul>
<p>以及一些可以用于本地开发使用的开源工具如：</p>
<ul>
<li><a href="https://github.com/abruzzi/node-build-monitor">基于Node的构建monitor</a></li>
<li><a href="https://toolbelt.heroku.com/">Heroku的命令行工具</a></li>
<li><a href="https://github.com/travis-ci/travis.rb">Travis CI的命令行工具</a></li>
</ul>
<p>除此之外，我们在过程中编写的脚本还可以用以本地构建，如果你的团队中正好已经有CI工具/CD工具，将这些脚本集成进去也是一件非常容易的事情。</p>
<p><img loading="lazy" src="/images/2016/01/heroku-log-resized.png" type="" alt="heroku real time log"  /></p>
<h2 id="背景知识">背景知识</h2>
<h3 id="软件的度量">软件的度量</h3>
<p>传统的管理方法论，在软件开发这个领域来说基本上是不工作的。软件项目的不确定性使得人们畏惧，管理者希望通过一些数字，指标来让自己感到某种虚幻的“掌控感”。软件行数，测试覆盖率，代码故障率等数字的名声基本上已经很糟了，经常有人拿来讽刺那些追求虚幻掌控感的“领导”。</p>
<p>但是有一个数字，即使最顽固的“自由主义者”也会认为是有意义的，那就是周期时间（cycle time）。简而言之，就是一个需求从产生到最终上线所需要的时间。其中包括了需求分析，设计，编码，测试，部署，运维等活动，可能还会包含后续的监控。</p>
<p>其实不论是瀑布模型，还是迭代开发的方式，或者其他的方法论，周期时间的缩短都是至关重要的。而具体到周期内，单纯的开发时间变长或者测试时间变长都无关紧要。比如项目A的开发时间是测试时间的2倍，项目B则恰恰反过来，这并不能说A做的比B好，真正有意义的是A的周期时间是否比B更短。</p>
<p>单纯改善项目过程中的某一个阶段的时间，可能并不能达到预期的目的。局部优化并不一定会带来全局的优化。换言之，<strong>通过某些策略来提高软件测试的效率未必能减少周期时间！</strong>。</p>
<h3 id="持续交付">持续交付</h3>
<p>传统情况下，企业要进行软件开发，从用户研究到产品上线，其中会花费数月，甚至数年（我的一位印度同事给我聊起过，他的上家公司做产品，从版本启动到版本上线需要整整两年时间！）。而且一旦软件需求发生变更，又有需要数月才能将变更发布上线。除了为变更提交代码外，还有很多额外的回归测试，发布计划，运维部门的进度等等。而市场机会千变万化，在特定的时间窗口中，企业的竞争者可能早已发布并占领了相当大的市场份额。</p>
<p>在软件工程领域，人们提出了持续交付（continuous delivery）的概念，它旨在减少周期时间，强调在任何时刻软件都处于可发布状态。采用这种实践，我们可以频繁，快速，安全的将需求的变化发布出来，交由真实世界的用户来使用，在为用户带来价值的同时，我们也可以快速，持续的得到反馈，并激励新的变化产生（新的商业创新，新的模式等）。</p>
<p>持续交付包含了自动化构建，自动化测试以及自动化部署等过程，持续改进开发流程中的问题，并促进开发人员，测试人员，运维人员之间的协作，团队可以在分钟级别将变更发布上线。</p>
<h3 id="持续交付相关技术及实践">持续交付相关技术及实践</h3>
<ul>
<li>版本控制（配置管理）</li>
<li>持续集成CI</li>
<li>自动化测试</li>
<li>构建工具及构建脚本</li>
<li>部署流水线</li>
</ul>
<p>团队通过版本控制来进行协作，所有的代码会在持续集成环境中编译，代码静态检查/分析，自动化测试（还可能产生报告等）。除此之外，CI还还需要有自动化验收测试，自动化回归测试等。</p>
<p>持续交付则更进一步，它将环境准备，持续集成，自动化部署等放在了一起。通过全自动（有些过程可以设置为手动，比如发布到产品环境）的方式，使得软件可以一键发布。如果上线后发现严重defect，还支持一键回滚的机制（其实就是将之前的一个稳定版本做一次发布，由于发布流程已经经过千锤百炼，所以发布本身就变得非常轻松，安全）</p>
<p>这篇文章中，我们会使用<code>git</code>+<code>github</code>作为版本控制工具，<code>travis-ci</code>作为持续集成环境，<code>gradle</code>作为构建工具，<code>Heroku</code>作为应用的部署环境。这些工具都是免费服务，如果你需要更高级的功能（比如更多的并发数，更大的数据库），则可以选择付费套餐。不过对于我们平时的大部分side project来说，免费服务已经足够。</p>
<h2 id="实例">实例</h2>
<p>我在<a href="http://icodeit.org/2015/06/whats-next-after-separate-frontend-and-backend/">《前后端分离了，然后呢？》</a>这篇文章中，提到了一个叫做<code>bookmarks</code>的应用，这个应用是一个前后端分离的非常彻底的应用。</p>
<p>我们这里会再次使用这个应用作为实例，并采用不同的两个免费服务（<a href="https://travis-ci.org">travis-ci</a>和<a href="https://snap-ci.com">snap-ci</a>）来完成<code>持续部署</code>环境的搭建。</p>
<h3 id="bookmarks服务器">bookmarks服务器</h3>
<p><code>bookmarks-server</code>是一个基于<code>spring-boot</code>的纯粹的<code>API</code>，它可以被打包成一个<code>jar</code>包，然后通过命令行启动运行。在本文中，我们我们将会将这个server部署到<a href="https://dashboard.heroku.com/">heroku</a>平台上。</p>
<p>首先需要定义一个<code>Procfile</code>，这个是我们应用的入口，<code>heroku</code>根据这个文件来明确以何种方式来启动我们的应用：</p>
<pre><code>web: java -Dserver.port=$PORT -jar build/libs/bookmarks-server-0.1.0.jar --spring.profiles.active=staging
</code></pre><p>由于我们在本地使用的使用<code>mysql</code>，而<code>heroku</code>默认的是<code>postgres</code>数据库，因此需要在<code>application.yml</code>中额外配置</p>
<div class="highlight"><pre class="chroma"><code class="language-yml" data-lang="yml"><span class="nt">spring</span><span class="p">:</span><span class="w">
</span><span class="w">  </span><span class="nt">profiles</span><span class="p">:</span><span class="w"> </span><span class="l">staging</span><span class="w">
</span><span class="w">
</span><span class="w">  </span><span class="nt">datasource</span><span class="p">:</span><span class="w">
</span><span class="w">    </span><span class="nt">driverClassName</span><span class="p">:</span><span class="w"> </span><span class="l">org.postgresql.Driver</span><span class="w">
</span><span class="w">    </span><span class="nt">url</span><span class="p">:</span><span class="w"> </span><span class="l">${JDBC_DATABASE_URL}</span><span class="w">
</span><span class="w">    </span><span class="nt">username</span><span class="p">:</span><span class="w"> </span><span class="l">${DATABASE_USER}</span><span class="w">
</span><span class="w">    </span><span class="nt">password</span><span class="p">:</span><span class="w"> </span><span class="l">${DATABASE_PASS}</span><span class="w">
</span><span class="w">
</span><span class="w">  </span><span class="nt">jpa</span><span class="p">:</span><span class="w">
</span><span class="w">    </span><span class="nt">database_platform</span><span class="p">:</span><span class="w"> </span><span class="l">org.hibernate.dialect.PostgreSQLDialect</span><span class="w">
</span><span class="w">    </span><span class="nt">hibernate</span><span class="p">:</span><span class="w">
</span><span class="w">      </span><span class="nt">ddl-auto</span><span class="p">:</span><span class="w"> </span><span class="l">update</span><span class="w">
</span></code></pre></div><p>有了这些配置后，我们需要创建一个<code>heroku</code>应用：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ heroku create
Created http://quiet-atoll-8237.herokuapp.com/ <span class="p">|</span> git@heroku.com:quiet-atoll-8237.git
</code></pre></div><p>创建之后，我们可以在界面上对这个应用进行一些配置（当然，也可以通过命令行，具体参看<code>heroku help</code>）。为了支持数据库，需要为我们的应用添加一个<code>postgres</code>的AddOn。添加之后，<code>heroku</code>会为我们提供一个<code>postgres</code>的连接地址，格式大概是这样：</p>
<pre><code>postgres://username:password@host:port/database
</code></pre><p>然后我们需要在<code>Heroku</code>的配置界面中配置一些环境变量：</p>
<p><img loading="lazy" src="/images/2016/01/heroku-config-resized.png" type="" alt="heroku env config"  /></p>
<p>这样，当应用部署到<code>Heroku</code>上之后，我们的应用就可以读到这些配置了（注意<code>application.yml</code>中的环境变量<code>JDBC_DATABASE_URL</code>）。</p>
<h4 id="搭建持续集成环境">搭建持续集成环境</h4>
<p>持续集成环境，这里我们选用最简单的<code>travis-ci</code>，它可以很容易的与<code>github</code>集成。</p>
<ul>
<li>在项目X中定义一个<code>.travis.yml</code>的文件</li>
<li>将你的代码push到github上</li>
<li>绑定github帐号到<code>travis</code></li>
<li>在<code>travis</code>中启用项目X</li>
</ul>
<p>这个<code>.travis.yml</code>因项目而异，我们这里的项目是<code>spring-boot</code>，所以只需要指定<code>java</code>即可：</p>
<div class="highlight"><pre class="chroma"><code class="language-yml" data-lang="yml"><span class="nt">language</span><span class="p">:</span><span class="w"> </span><span class="l">java</span><span class="w">
</span></code></pre></div><p>如果是<code>java</code>项目，并且项目中有<code>build.gradle</code>，<code>travis-ci</code>会自动执行<code>gradle check</code>任务。</p>
<h4 id="自动化部署">自动化部署</h4>
<p>当CI运行成功之后，我们需要<code>travis-ci</code>帮我们将应用程序发布到<code>heroku</code>上，这时候需要做一些修改。最简单的方式是直接安装<code>travis-ci</code>的命令行工具到本地：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ gem install travis -v 1.8.0 --no-rdoc --no-ri
</code></pre></div><p>然后通过<code>heroku</code>的<code>auth:token</code>命令获得<code>heroku</code>的token，在加密并写入<code>.travis.yml</code>：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ heroku auth:token
00xxxxxxxxxxxxx55d11dbd0cxxxxxxxxxxfe067

$ travis encrypt 00xxxxxxxxxxxxx55d11dbd0cxxxxxxxxxxfe067 --add
</code></pre></div><p>当然可以合并为一条命令：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ travis encrypt <span class="k">$(</span>heroku auth:token<span class="k">)</span> --add
</code></pre></div><p>将加密过的token存入<code>.travis.yml</code>文件。最后的结果大致如下：</p>
<div class="highlight"><pre class="chroma"><code class="language-yml" data-lang="yml"><span class="nt">language</span><span class="p">:</span><span class="w"> </span><span class="l">java</span><span class="w">
</span><span class="w"></span><span class="nt">deploy</span><span class="p">:</span><span class="w">
</span><span class="w">  </span><span class="nt">provider</span><span class="p">:</span><span class="w"> </span><span class="l">heroku</span><span class="w">
</span><span class="w">  </span><span class="nt">api_key</span><span class="p">:</span><span class="w">
</span><span class="w">    </span><span class="nt">secure</span><span class="p">:</span><span class="w"> </span><span class="l">...</span><span class="w">
</span><span class="w">  </span><span class="nt">app</span><span class="p">:</span><span class="w"> </span><span class="l">quiet-atoll-8237</span><span class="w">
</span></code></pre></div><p>注意此处的<code>app</code>，正是我们的App的名字。另外，还需要给<code>build.gradle</code>添加一个名叫<code>stage</code>的task，<code>travis</code>在deploy时需要这个<code>task</code>：</p>
<div class="highlight"><pre class="chroma"><code class="language-groovy" data-lang="groovy"><span class="n">task</span> <span class="n">stage</span> <span class="o">{</span>
    <span class="n">dependsOn</span> <span class="n">build</span>
<span class="o">}</span>
</code></pre></div><p><img loading="lazy" src="/images/2016/01/travis-deploy-resized.png" type="" alt="travis deploy"  /></p>
<p>这样，我们只需要在本地的一个提交，一切都会自动化起来：</p>
<ul>
<li>travis会执行<code>gradle check</code></li>
<li><code>gradle check</code>会编译并运行自动化测试</li>
<li><code>travis</code>会部署应用到<code>heroku</code>上</li>
<li><code>heroku</code>会自动重启服务</li>
</ul>
<p>我们可以在本地进行简单的测试（注意此处我们的<code>staging</code>环境的URL）：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh">$ curl https://quiet-atoll-8237.herokuapp.com/api/feeds -s <span class="p">|</span> jq .
<span class="o">[</span>
  <span class="o">{</span>
    <span class="s2">&#34;id&#34;</span>: 1,
    <span class="s2">&#34;url&#34;</span>: <span class="s2">&#34;http://icodeit.org/2016/01/how-to-summarize-privious-project/&#34;</span>,
    <span class="s2">&#34;title&#34;</span>: <span class="s2">&#34;如何持久化你的项目经历&#34;</span>,
    <span class="s2">&#34;author&#34;</span>: <span class="s2">&#34;icodit.org&#34;</span>,
    <span class="s2">&#34;summary&#34;</span>: <span class="s2">&#34;通常来说，下项目总是一件比较高兴的事（大部分团队还会一起吃个饭庆祝一下）。&#34;</span>,
    <span class="s2">&#34;publishDate&#34;</span>: <span class="s2">&#34;2016-01-07&#34;</span>
  <span class="o">}</span>,
  <span class="o">{</span>
    <span class="s2">&#34;id&#34;</span>: 2,
    <span class="s2">&#34;url&#34;</span>: <span class="s2">&#34;http://icodeit.org/2015/11/get-started-with-reflux/&#34;</span>,
    <span class="s2">&#34;title&#34;</span>: <span class="s2">&#34;你为什么应该试一试Reflux？&#34;</span>,
    <span class="s2">&#34;author&#34;</span>: <span class="s2">&#34;icodit.org&#34;</span>,
    <span class="s2">&#34;summary&#34;</span>: <span class="s2">&#34;React在设计之初就只关注在View本身上，其余部分如数据的获取，事件处理等，全然不在考虑之内。&#34;</span>,
    <span class="s2">&#34;publishDate&#34;</span>: <span class="s2">&#34;2016-01-09&#34;</span>
  <span class="o">}</span>
<span class="o">]</span>
</code></pre></div><p>完整的<a href="https://github.com/abruzzi/bookmarks-server">代码在这里</a>。</p>
<h2 id="其他">其他</h2>
<h3 id="ci-monitor">CI monitor</h3>
<p><a href="https://github.com/abruzzi/node-build-monitor">node-build-monitor</a>是一个非常容易配置，使用的CI monitor，我们只需要进行简单地配置，就可以将<code>travis</code>的状态可视化出来</p>
<div class="highlight"><pre class="chroma"><code class="language-json" data-lang="json"><span class="p">{</span>
  <span class="nt">&#34;monitor&#34;</span><span class="p">:</span> <span class="p">{</span>
    <span class="nt">&#34;interval&#34;</span><span class="p">:</span> <span class="mi">2000</span><span class="p">,</span>
    <span class="nt">&#34;numberOfBuilds&#34;</span><span class="p">:</span> <span class="mi">12</span><span class="p">,</span>
    <span class="nt">&#34;debug&#34;</span><span class="p">:</span> <span class="kc">true</span>
  <span class="p">},</span>
  <span class="nt">&#34;services&#34;</span><span class="p">:</span> <span class="p">[</span>
    <span class="p">{</span>
      <span class="nt">&#34;name&#34;</span><span class="p">:</span> <span class="s2">&#34;Travis&#34;</span><span class="p">,</span>
      <span class="nt">&#34;configuration&#34;</span><span class="p">:</span> <span class="p">{</span>
        <span class="nt">&#34;slug&#34;</span><span class="p">:</span> <span class="s2">&#34;abruzzi/bookmarks-server&#34;</span>
      <span class="p">}</span>
    <span class="p">}</span>
  <span class="p">]</span>
<span class="p">}</span>
</code></pre></div><p>不过这个工具会在有网络异常时自动终止，我们可以通过一个简单的脚本来在它终止时自动重启：</p>
<div class="highlight"><pre class="chroma"><code class="language-sh" data-lang="sh"><span class="cp">#!/bin/bash
</span><span class="cp"></span>
<span class="k">until</span> node app/app.js
<span class="k">do</span>
    <span class="nb">echo</span> <span class="s2">&#34;restarting...&#34;</span>
<span class="k">done</span>
</code></pre></div><p><img loading="lazy" src="/images/2016/01/ci-monitor-resized.png" type="" alt="CI Monitor"  /></p>
<h2 id="小结">小结</h2>
<p>通过<code>travis</code>和<code>heroku</code>这样的免费服务，我们就可以轻松的将自己的项目做到持续集成+持续交付。我们后端的服务相对来说是比较容易的，但是涉及到一个前后端分离的架构，如何做到静态内容的托管，打包，部署，并和后端API集成起来，我会在下一篇文章中详细解释。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>如何总结你的上一个项目</title>
      <link>https://icodeit.org/2016/01/how-to-summarize-privious-project/</link>
      <pubDate>Tue, 05 Jan 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/01/how-to-summarize-privious-project/</guid>
      <description>下项目之后 通常来说，下项目总是一件比较高兴的事（大部分团队还会一起吃个饭庆祝一下）。这里面既有终于摆脱了厌烦了的技术栈的解脱感，也有对新项目/新技术的向往，可能还有些在旧项目中做的不太满意的事情，可以在新项目重头再来的期望。
可能有点老生常谈了，不过这里我想说说下项目后如何做总结的事儿。对上一个项目的总结，其重要程度可能要远远超过你的想象。我是在2014年初，在一个客户现场的一个会议室和一位同事谈我的Annual Review的时候，才意识到这个问题的。
Annual Review会回顾我们过去一年的项目经历，有哪些方面的进步，同时也会展望未来的计划。但是这其中有几个问题：第一个问题是以年为单位的Review粒度太粗，有些经历已经淡忘，也有人可能一年会换好几个项目；第二个问题是对于大多数人来说，展望未来是一件比较容易的事儿，每个人或多或少都会有一些计划（比如学会前端的某些技术，尝试一些DevOps方面的工作，或者了解一下大数据等等）；但是对于回顾过去，我们其实并不擅长；最后一个问题是即使做了回顾，回顾的层次非常浅，作用并不大。
说到回顾过去，更多时候我们关注的是从项目中学到了什么样的新技术，这种浅层次的回忆和记流水帐是容易的，但是对于我们的成长并不会有太大的收益。真正会为帮助我们在将来的项目中做决策，甚至会影响我们学习效率，解决问题能力的是：深度回顾。
深度回顾练习 深度回顾可以帮助我们梳理知识，将实际的案例归纳总结为实际可用的知识。要获得这种能力，需要做一些针对性的练习。根据我自己的经验，这些练习大约可以归为3类，难度依次增加。
项目上的直接经验 这个练习比较简单，就是问问自己：“我在项目里学到了什么？”
要回答这个问题是很容易的，项目中用到的技术如模板引擎，前端框架，自动化测试套件，build工具等等，总结这些内容的过程，对于我们的PS来说都是“自动”发生的，几乎不需要付出额外的efforts。这些回顾、总结可以帮助我们成为一个“熟手”，即当下一次遇到相同或者类似的场景时，我们可以很容易直接应用这些经验。
更进一步，再问问自己在项目中的其他收获。比如客户关系处理的经历，团队建设的经验，甚至是写英文邮件的技巧等等方面，看看做的有没有问题，有没有提升的可能？
人类最牛逼的技能是：可以审视自己的行为。也就是站在旁观者的角度来看待自己的行为，随波逐流式的在各种琐事中沉浮事实上无法得到提升的。可以经常性的将自己置身事外，以一个旁观者的角度来审视自己做过的事情。并从中找出做得好的地方和不足的地方，然后自己给过去的自己一些建议，并记录下来。这些刻意的练习会帮助你养成回顾，从经验中学习的习惯，而这个习惯正是一个人区别于另一个人的绝对“捷径”。
练习讲故事 这个练习是，假想你遇到了一个同一个办公室的同事，他对你刚做完的这个项目很感兴趣，你来给他描述一下这个项目。描述的内容包括但不限于这些方面：
 项目的背景介绍 该项目以何种方式，为那些用户，带来了什么样的价值？（business model是什么） 该项目的实际用户数量是什么级别？ 项目的部署，运维是如何操作的？ 项目的监控是怎样做的？ 当遇到系统故障，项目组是如何反应的？  能把一件事情描述清楚是一件非常了不起的能力。我见过很多的程序员，写起代码来好不含糊，但是却很难将一件简单的事情讲清楚。我们当然要提防那些夸夸其谈，华而不实的“嘴子”，但是也至少得要求自己做到清晰，准确的将自己经历过的事情描述清楚。
描述项目背景需要至少需要交代这样一些内容：客户是谁，最终的消费者是谁，项目以何种方式运作（离岸交付，本地，onsite，咨询，培训等），我们帮助客户为消费者带来了什么样的价值。客户的商业模式是什么，在我们周围有哪些类似的项目。
即使在技术方面，也有很多被Dev忽略掉的信息，比如项目在产品环境中如何部署，数据中心建在何处，客户如何运维、监控等。实际的发布周期如何，发布流程如何，客户的内部论坛上都会有很多的这样的信息，但是很少有人关注。从一个项目roll off的时候，这些信息即使做不到了若指掌，至少也能描述清楚，否则难免有些“入宝山而空回”的遗憾。
回顾项目中的挑战 从简单的CRUD系统，到复杂的分布式计算，从企业内部的管理系统，到支持高并发、要求实时处理的交易平台，每个项目都会遇到一些挑战。除了技术上的挑战之外，还有陈旧而无文档的代码库，复杂的业务场景，不配和的客户接口人等等。挑战无处不在，那么作为项目中的一员，你是如何应对这些挑战的呢？最后又是如何解决的？
现实世界是一个充满了trade off的世界，我们需要做种种权衡，代码测试覆盖率和交付压力，性能和客户能负担的机器实例数量，框架A和框架B的优劣等等。我们在采取这个方案的时候，只能舍弃其他方案，由于谁也无法在事先准确预料采取某个方案一定是对的，那么在一个失败的方案背后，其实也是一个很好的教训，至少可以为未来的决策提供帮助。
 遇到的最大的挑战是什么？ 这个挑战是如何被解决的？ 如果有机会重做，你会如何考虑？  其他练习 这里列出了一些我常用的，辅助性的练习。它们可以帮助你更好的梳理项目上学到的技能、知识，并且转换成你自己的知识。这些练习未必一定要等到项目结束之后才做，事实上它们都可以应用在日常的工作中。
 记笔记 写博客 在办公室内演讲 去社区贡献话题  很多人都会记笔记，但只有一小部分的人在记录之后会持续翻阅。很多人会使用Evernote/印象笔记之类的工具将一些临时的想法，问题的思路，知识点的细节等记录下来，但是仅仅记录是不够的，笔记需要不断的检索、整理、提炼、修正、总结和归纳。在不断的加工之后，这些笔记可能会得到沉淀，并升华形成一些更有意义的内容（比如个人博客，或者可以发表到InfoQ/IBM DeveloperWorks平台上的文章等）。
除了记录笔记之外，写博客也是一种很好的总结形式。通过将素材不断充实、整理、完善，最终形成一个可供别人直接消费的文章，不但可以锻炼到总结能力，还可以很好的提升表达能力，而且可以帮助你将已有的知识体系化。如果你的博客写成了系列，也很容易通过Gitbook等将其发布为一本电子书，从而影响更多人（说不定还可以赚点咖啡钱）。
写博客/电子书，终究是书面形式的。事实上一个人可以很容易的通过文字将自己的实际情况隐藏起来。举个极端的例子：如果有足够的动机（比如公司的KPI要求），即使不熟悉某种语言/工具，仅仅通过Google，一个人也可以通过这种“作弊”的方式写出一篇“专家级”的文章。但是对于演讲这种面对面的形式，则基本上无法作弊，从而也更具有挑战性。另一方面，对于一个新的知识、技能，自己掌握是一回事儿，要讲出来让别人也能听懂，并从中收益，则完全是另外一回事儿。作为咨询师，语言表达（包括书面和演讲）能力的重要性勿庸赘言。整理知识，并归纳为演讲，会帮助你将体系化后的知识更好的表达出来。
在办公室里讲session有一定的挑战，但受众毕竟是“自己人”，压力相对会小一些（比如在ThoughtWorks，我们非常鼓励员工为其他人讲session，具体可以参看我的这篇文章）。要在社区中演讲则要面临更大的挑战，通过将话题不断锤炼，不断归纳，最终形成可以在社区分享的话题，则不但可以提高内容的质量，也可以更好的锻炼表达能力和临场应变能力。
不过归根结底，这些活动的重要输入还是对之前项目中的知识、经历的深度回顾。
总结 从项目上下来之后，需要深入思考并总结之前的经验，这种深入思考会帮助你建立比较完整的知识体系，也可以让你在下一项目中更加得心应手，举一反三。如果只是蜻蜓点水般的“经历”了若干个项目，而不进行深入的总结和思考，相当于把相同的项目用不同的技术栈做了很多遍一样，那和我们平时所痛恨的重复代码又有什么不同呢？</description>
      <content:encoded><![CDATA[<h1 id="下项目之后">下项目之后</h1>
<p>通常来说，下项目总是一件比较高兴的事（大部分团队还会一起吃个饭庆祝一下）。这里面既有终于摆脱了厌烦了的<code>技术栈</code>的解脱感，也有对新项目/新技术的向往，可能还有些在旧项目中做的不太满意的事情，可以在新项目重头再来的期望。</p>
<p>可能有点老生常谈了，不过这里我想说说下项目后如何做总结的事儿。对上一个项目的总结，其重要程度可能要远远超过你的想象。我是在2014年初，在一个客户现场的一个会议室和一位同事谈我的Annual Review的时候，才意识到这个问题的。</p>
<p>Annual Review会回顾我们过去一年的项目经历，有哪些方面的进步，同时也会展望未来的计划。但是这其中有几个问题：第一个问题是以年为单位的Review粒度太粗，有些经历已经淡忘，也有人可能一年会换好几个项目；第二个问题是对于大多数人来说，展望未来是一件比较容易的事儿，每个人或多或少都会有一些计划（比如学会前端的某些技术，尝试一些DevOps方面的工作，或者了解一下大数据等等）；但是对于回顾过去，我们其实并不擅长；最后一个问题是即使做了回顾，回顾的层次非常浅，作用并不大。</p>
<p>说到回顾过去，更多时候我们关注的是从项目中学到了什么样的新技术，这种浅层次的回忆和记流水帐是容易的，但是对于我们的成长并不会有太大的收益。真正会为帮助我们在将来的项目中做决策，甚至会影响我们学习效率，解决问题能力的是：<code>深度回顾</code>。</p>
<h2 id="深度回顾练习">深度回顾练习</h2>
<p>深度回顾可以帮助我们梳理知识，将实际的案例归纳总结为实际可用的知识。要获得这种能力，需要做一些针对性的练习。根据我自己的经验，这些练习大约可以归为3类，难度依次增加。</p>
<h3 id="项目上的直接经验">项目上的直接经验</h3>
<p>这个练习比较简单，就是问问自己：“<strong>我在项目里学到了什么？</strong>”</p>
<p>要回答这个问题是很容易的，项目中用到的技术如模板引擎，前端框架，自动化测试套件，build工具等等，总结这些内容的过程，对于我们的PS来说都是“自动”发生的，几乎不需要付出额外的efforts。这些回顾、总结可以帮助我们成为一个“熟手”，即当下一次遇到相同或者类似的场景时，我们可以很容易直接应用这些经验。</p>
<p>更进一步，再问问自己在项目中的其他收获。比如客户关系处理的经历，团队建设的经验，甚至是写英文邮件的技巧等等方面，看看做的有没有问题，有没有提升的可能？</p>
<p>人类最牛逼的技能是：可以审视自己的行为。也就是站在旁观者的角度来看待自己的行为，随波逐流式的在各种琐事中沉浮事实上无法得到提升的。可以经常性的将自己置身事外，以一个旁观者的角度来审视自己做过的事情。并从中找出做得好的地方和不足的地方，然后自己给过去的自己一些建议，并记录下来。这些刻意的练习会帮助你养成回顾，从经验中学习的习惯，而这个习惯正是一个人区别于另一个人的绝对“捷径”。</p>
<h3 id="练习讲故事">练习讲故事</h3>
<p>这个练习是，假想你遇到了一个同一个办公室的同事，他对你刚做完的这个项目很感兴趣，你来给他描述一下这个项目。描述的内容包括但不限于这些方面：</p>
<ul>
<li>项目的背景介绍</li>
<li>该项目以何种方式，为那些用户，带来了什么样的价值？（business model是什么）</li>
<li>该项目的实际用户数量是什么级别？</li>
<li>项目的部署，运维是如何操作的？</li>
<li>项目的监控是怎样做的？</li>
<li>当遇到系统故障，项目组是如何反应的？</li>
</ul>
<p>能把一件事情描述清楚是一件非常了不起的能力。我见过很多的程序员，写起代码来好不含糊，但是却很难将一件简单的事情讲清楚。我们当然要提防那些夸夸其谈，华而不实的“嘴子”，但是也至少得要求自己做到清晰，准确的将自己经历过的事情描述清楚。</p>
<p>描述项目背景需要至少需要交代这样一些内容：客户是谁，最终的消费者是谁，项目以何种方式运作（离岸交付，本地，onsite，咨询，培训等），我们<strong>帮助客户为消费者带来了什么样的价值</strong>。客户的商业模式是什么，在我们周围有哪些类似的项目。</p>
<p><img loading="lazy" src="/images/2016/01/bmcanvas-basic-model-resized.jpg" type="" alt="business canvas"  /></p>
<p>即使在技术方面，也有很多被Dev忽略掉的信息，比如项目在产品环境中如何部署，数据中心建在何处，客户如何运维、监控等。实际的发布周期如何，发布流程如何，客户的内部论坛上都会有很多的这样的信息，但是很少有人关注。从一个项目roll off的时候，这些信息即使做不到了若指掌，至少也能描述清楚，否则难免有些“入宝山而空回”的遗憾。</p>
<h3 id="回顾项目中的挑战">回顾项目中的挑战</h3>
<p>从简单的CRUD系统，到复杂的分布式计算，从企业内部的管理系统，到支持高并发、要求实时处理的交易平台，每个项目都会遇到一些挑战。除了技术上的挑战之外，还有陈旧而无文档的代码库，复杂的业务场景，不配和的客户接口人等等。挑战无处不在，那么作为项目中的一员，你是如何应对这些挑战的呢？最后又是如何解决的？</p>
<p>现实世界是一个充满了trade off的世界，我们需要做种种权衡，代码测试覆盖率和交付压力，性能和客户能负担的机器实例数量，框架A和框架B的优劣等等。我们在采取这个方案的时候，只能舍弃其他方案，由于谁也无法在事先准确预料采取某个方案一定是对的，那么在一个失败的方案背后，其实也是一个很好的教训，至少可以为未来的决策提供帮助。</p>
<ul>
<li>遇到的最大的挑战是什么？</li>
<li>这个挑战是如何被解决的？</li>
<li>如果有机会重做，你会如何考虑？</li>
</ul>
<h3 id="其他练习">其他练习</h3>
<p>这里列出了一些我常用的，辅助性的练习。它们可以帮助你更好的梳理项目上学到的技能、知识，并且转换成你自己的知识。这些练习未必一定要等到项目结束之后才做，事实上它们都可以应用在日常的工作中。</p>
<ul>
<li>记笔记</li>
<li>写博客</li>
<li>在办公室内演讲</li>
<li>去社区贡献话题</li>
</ul>
<p>很多人都会记笔记，但只有一小部分的人在记录之后会持续翻阅。很多人会使用Evernote/印象笔记之类的工具将一些临时的想法，问题的思路，知识点的细节等记录下来，但是仅仅记录是不够的，笔记需要不断的检索、整理、提炼、修正、总结和归纳。在不断的加工之后，这些笔记可能会得到沉淀，并升华形成一些更有意义的内容（比如个人博客，或者可以发表到InfoQ/IBM DeveloperWorks平台上的文章等）。</p>
<p>除了记录笔记之外，写博客也是一种很好的总结形式。通过将素材不断充实、整理、完善，最终形成一个可供别人直接消费的文章，不但可以锻炼到总结能力，还可以很好的提升表达能力，而且可以帮助你将已有的知识体系化。如果你的博客写成了系列，也很容易通过Gitbook等将其发布为一本电子书，从而影响更多人（说不定还可以赚点咖啡钱）。</p>
<p>写博客/电子书，终究是书面形式的。事实上一个人可以很容易的通过文字将自己的实际情况隐藏起来。举个极端的例子：如果有足够的动机（比如公司的KPI要求），即使不熟悉某种语言/工具，仅仅通过Google，一个人也可以通过这种“作弊”的方式写出一篇“专家级”的文章。但是对于演讲这种面对面的形式，则基本上无法作弊，从而也更具有挑战性。另一方面，对于一个新的知识、技能，自己掌握是一回事儿，要讲出来让别人也能听懂，并从中收益，则完全是另外一回事儿。作为咨询师，语言表达（包括书面和演讲）能力的重要性勿庸赘言。整理知识，并归纳为演讲，会帮助你将体系化后的知识更好的表达出来。</p>
<p>在办公室里讲session有一定的挑战，但受众毕竟是“自己人”，压力相对会小一些（比如在ThoughtWorks，我们非常鼓励员工为其他人讲session，具体可以参看<a href="http://icodeit.org/2015/01/how-we-do-training-in-thoughtworks/">我的这篇文章</a>）。要在社区中演讲则要面临更大的挑战，通过将话题不断锤炼，不断归纳，最终形成可以在社区分享的话题，则不但可以提高内容的质量，也可以更好的锻炼表达能力和临场应变能力。</p>
<p><img loading="lazy" src="/images/2016/01/xian-resized.jpg" type="" alt="xian community"  /></p>
<p>不过归根结底，这些活动的重要输入还是对之前项目中的知识、经历的深度回顾。</p>
<h2 id="总结">总结</h2>
<p>从项目上下来之后，需要深入思考并总结之前的经验，这种深入思考会帮助你建立比较完整的知识体系，也可以让你在下一项目中更加得心应手，举一反三。如果只是蜻蜓点水般的“经历”了若干个项目，而不进行深入的总结和思考，相当于把相同的项目用不同的技术栈做了很多遍一样，那和我们平时所痛恨的重复代码又有什么不同呢？</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>我的2015</title>
      <link>https://icodeit.org/2016/01/my-2015/</link>
      <pubDate>Sat, 02 Jan 2016 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2016/01/my-2015/</guid>
      <description>2015年总结 2015年在不经意间就过去了。又是一年。按照惯例，我会在年末回顾一下这一年自己的进步，收获以及一些感慨（牢骚）。然后对来年做一点展望，看看什么地方可以做的更好。
项目经历 今年基本上经历了三个项目，性质也都不一样：
 海外交付 国内交付 国内售前  3月前的项目以及没有什么印象了，依稀觉得项目上的所有实践都是“错”的，可能由于太过与荒诞，所以大脑自行将这段抹去了。
4月到6月在深圳的一个国内交付项目上，交付压力还挺大。不过也是在这个项目上，非常直接的体会到了其他角色的不容易。无论是客户的接口人，客户的项目经理，客户的领导，我们的开发，我们的UX，项目经理，还有交付的lead，所有人都不容易。
《项目经理是大傻逼吗》这篇文章就是为了纪念这个项目，或者说是被这个项目驱动出来的。
6月之后回到办公室，在一个海外交付项目上。说是一个项目，中间其实换了6，7个不同的工作内容（出钱的是同一个客户而已）。总之一片混乱，所幸我们在10月前就结束了和这个客户的合作。这个项目事实上除了锻炼项目上人的耐心外，基本毫无益处。甚至对于很多毕业生来说，是深刻的伤害。
10月之后，我难得的在beach上待了下来，而且一待就是3个月。中间在一个联合国的项目上工作了2周，然后就是为另外一个咨询项目准备了几周方案。当然，闲是不可能闲着的。在beach上，如果不出意外，肯定会比项目上更忙！比如打黑工啊，内部什么系统的改进啊，总是有好多事情。
由于有一些本地的项目机会，而我又不在具体项目上，就来做这个售前的角色。帮助客户梳理需求，分析问题，设计方案，计算工作量等等。但是这个过程往往循环往复，一轮接着一轮，在合同确认之前，需要很多次讨论和交流。这应该不会是我自己的一个方向，在项目上写代码，培养新人，分享自己的学习所得，和他人一起进步，是我自己比较有热情的方向。
技术方面 在海外交付项目上，乏善足陈，项目中用到的也是非常厚重，已经至少10年的技术。通常来看，这样的大组织，没有人对要做的事情真正关心。好不容易遇到一个特别靠谱的人，结果我们的项目又结束了。国内项目上倒是有很多有意思的东西：
 如何在前端代码中很好的使用MVC 流畅的前端开发模式 如何做前端的测试  上面这三点，我希望可以找时间整理出一本电子书，可以让没有工程级做过项目的前端工程师能有一个参考。
另一方面，由于项目的压力，和项目人员的特殊性（开发就俩人，一个做前端，一个做后端，要集成就pair一下），所以很多实践都没有应用，比如结对，自动化测试等，做的都不够好。虽然我们很推崇，强调CI/CD的实践，但是当和客户的后端系统集成时，就各种悲剧。
联合国的项目上，技术栈比较新颖，上一家的技术人员使用了他们当时能找到的所有酷炫的新技术，并用在了项目中，然后他们公司被收购。留给我们的在今年来看，依然是比较新的：
 React Reflux ES6 mocha/chai  而在国内售前，基本上没有写过一行代码，更多是更高层次（高不一定是好哦）的工作。确认需求，估算工作量，确定方案（前后端测试，开发方式，部署策略，自动化测试等等）。
2016年，我希望可以多学习一些具体的编程知识，比如：
 mongodb 数据分析，数据挖掘 容器技术如docker  书籍 今年读了一些技术方面的书，更多的则是一些非技术类的。《自私的基因》是在2012年11月去墨尔本时，在广州白云机场买的，路上10个小时，读了几页。直到2015年才又拿起来，读了两章左右，基本上颠覆了我之前建立的对“进化论”的认识。
另外读了一些科普类的，比如《哲学家在干了些什么》，《上帝掷骰子吗》等，又扫了一次盲。再就是一些佛教相关的书籍，《西藏生死书》，《能断：金刚经》，《正见》等，人生观和价值观得到了刷新。
技术类的，主要是一些与具体技术关系不太大的，比如《恰如其分的软件架构》，《企业级应用架构模式》，《发布！》，《实例化需求》，《持续发布》之类。
虽然竣工于2014年，但是我的一本著作和一本译作都是2015年才发布出来，那就算作2015年的吧：
 《轻量级Web应用开发》 《7周7Web框架》  社区 今年在深圳的时候，有幸和ThoughtWorks的首席科学家马丁.福勒在同一次活动中作为讲师。
回到西安之后，在本地社区中还讲过一个前端工程师需要掌握的技能列表的session
2016年希望可以做一些更加深入的topic，以及一些更有意思，可以帮助到更多已经在路上的工程师们。
People Development 这个不知道如何翻译了，但是确实做了一些具体的事情：
 给我的sponsee们安排了读书会 组织了一次《编写可维护的JavaScript》的workshop 组织sponsee来做一个side project 组织《Web开发实战》的workshop  我自己总结出来了一套组织workshop的方式，其实很简单：
 做好计划，做好课表，做好课件 找学员，同时从学员里找出有基础，而且有意愿接着run workshop的人 讲课，收集feedback，并改进课表，课件 将run workshop的任务传递给那些有基础，而且有意愿接着run workshop的人  2016年希望可以找到更多的候选人，并帮助他们成为更好的讲师，教练。</description>
      <content:encoded><![CDATA[<h1 id="2015年总结">2015年总结</h1>
<p>2015年在不经意间就过去了。又是一年。按照惯例，我会在年末回顾一下这一年自己的进步，收获以及一些感慨（牢骚）。然后对来年做一点展望，看看什么地方可以做的更好。</p>
<h2 id="项目经历">项目经历</h2>
<p>今年基本上经历了三个项目，性质也都不一样：</p>
<ul>
<li>海外交付</li>
<li>国内交付</li>
<li>国内售前</li>
</ul>
<p>3月前的项目以及没有什么印象了，依稀觉得项目上的所有实践都是“错”的，可能由于太过与荒诞，所以大脑自行将这段抹去了。</p>
<p>4月到6月在深圳的一个国内交付项目上，交付压力还挺大。不过也是在这个项目上，非常直接的体会到了其他角色的不容易。无论是客户的接口人，客户的项目经理，客户的领导，我们的开发，我们的UX，项目经理，还有交付的lead，所有人都不容易。</p>
<p><a href="http://icodeit.org/2015/07/is-project-manager-a-fool/">《项目经理是大傻逼吗》</a>这篇文章就是为了纪念这个项目，或者说是被这个项目驱动出来的。</p>
<p>6月之后回到办公室，在一个海外交付项目上。说是一个项目，中间其实换了6，7个不同的工作内容（出钱的是同一个客户而已）。总之一片混乱，所幸我们在10月前就结束了和这个客户的合作。这个项目事实上除了锻炼项目上人的耐心外，基本毫无益处。甚至对于很多毕业生来说，是深刻的伤害。</p>
<p>10月之后，我难得的在beach上待了下来，而且一待就是3个月。中间在一个联合国的项目上工作了2周，然后就是为另外一个咨询项目准备了几周方案。当然，闲是不可能闲着的。在beach上，如果不出意外，肯定会比项目上更忙！比如打黑工啊，内部什么系统的改进啊，总是有好多事情。</p>
<p>由于有一些本地的项目机会，而我又不在具体项目上，就来做这个售前的角色。帮助客户梳理需求，分析问题，设计方案，计算工作量等等。但是这个过程往往循环往复，一轮接着一轮，在合同确认之前，需要很多次讨论和交流。这应该不会是我自己的一个方向，在项目上写代码，培养新人，分享自己的学习所得，和他人一起进步，是我自己比较有热情的方向。</p>
<h2 id="技术方面">技术方面</h2>
<p>在海外交付项目上，乏善足陈，项目中用到的也是非常厚重，已经至少10年的技术。通常来看，这样的大组织，没有人对要做的事情真正关心。好不容易遇到一个特别靠谱的人，结果我们的项目又结束了。国内项目上倒是有很多有意思的东西：</p>
<ul>
<li>如何在前端代码中很好的使用MVC</li>
<li>流畅的前端开发模式</li>
<li>如何做前端的测试</li>
</ul>
<p>上面这三点，我希望可以找时间整理出一本电子书，可以让没有<code>工程级</code>做过项目的前端工程师能有一个参考。</p>
<p>另一方面，由于项目的压力，和项目人员的特殊性（开发就俩人，一个做前端，一个做后端，要集成就pair一下），所以很多实践都没有应用，比如结对，自动化测试等，做的都不够好。虽然我们很推崇，强调CI/CD的实践，但是当和客户的后端系统集成时，就各种悲剧。</p>
<p>联合国的项目上，技术栈比较新颖，上一家的技术人员使用了他们当时能找到的所有酷炫的新技术，并用在了项目中，然后他们公司被收购。留给我们的在今年来看，依然是<a href="http://icodeit.org/2015/11/get-started-with-reflux/">比较新的</a>：</p>
<ul>
<li>React</li>
<li>Reflux</li>
<li>ES6</li>
<li>mocha/chai</li>
</ul>
<p>而在国内售前，基本上没有写过一行代码，更多是更高层次（高不一定是好哦）的工作。确认需求，估算工作量，确定方案（前后端测试，开发方式，部署策略，自动化测试等等）。</p>
<p>2016年，我希望可以多学习一些具体的编程知识，比如：</p>
<ul>
<li>mongodb</li>
<li>数据分析，数据挖掘</li>
<li>容器技术如docker</li>
</ul>
<h2 id="书籍">书籍</h2>
<p>今年读了一些技术方面的书，更多的则是一些非技术类的。《自私的基因》是在2012年11月去墨尔本时，在广州白云机场买的，路上10个小时，读了几页。直到2015年才又拿起来，读了两章左右，基本上颠覆了我之前建立的对“进化论”的认识。</p>
<p>另外读了一些科普类的，比如《哲学家在干了些什么》，《上帝掷骰子吗》等，又扫了一次盲。再就是一些佛教相关的书籍，《西藏生死书》，《能断：金刚经》，《正见》等，人生观和价值观得到了刷新。</p>
<p>技术类的，主要是一些与具体技术关系不太大的，比如《恰如其分的软件架构》，《企业级应用架构模式》，《发布！》，《实例化需求》，《持续发布》之类。</p>
<p>虽然竣工于2014年，但是我的一本著作和一本译作都是2015年才发布出来，那就算作2015年的吧：</p>
<ul>
<li><a href="http://www.amazon.cn/gp/product/B012R5A1NQ">《轻量级Web应用开发》</a></li>
<li><a href="http://www.amazon.cn/dp/B015317A94">《7周7Web框架》</a></li>
</ul>
<h2 id="社区">社区</h2>
<p>今年在深圳的时候，有幸和ThoughtWorks的首席科学家<code>马丁.福勒</code>在同一次活动中作为讲师。</p>
<p><img loading="lazy" src="/images/2016/01/shenzhen-resized.jpg" type="" alt="shenzhen"  /></p>
<p>回到西安之后，在本地社区中还讲过一个<code>前端工程师需要掌握的技能列表</code>的session</p>
<p><img loading="lazy" src="/images/2016/01/xian-resized.jpg" type="" alt="xian"  /></p>
<p>2016年希望可以做一些更加深入的topic，以及一些更有意思，可以帮助到更多已经<code>在路上</code>的工程师们。</p>
<h2 id="people-development">People Development</h2>
<p>这个不知道如何翻译了，但是确实做了一些具体的事情：</p>
<ul>
<li>给我的sponsee们安排了读书会</li>
<li>组织了一次《编写可维护的JavaScript》的workshop</li>
<li>组织sponsee来做一个side project</li>
<li>组织《Web开发实战》的workshop</li>
</ul>
<p>我自己总结出来了一套组织workshop的方式，其实很简单：</p>
<ol>
<li>做好计划，做好课表，做好课件</li>
<li>找学员，同时从学员里找出<code>有基础，而且有意愿接着run workshop的人</code></li>
<li>讲课，收集feedback，并改进课表，课件</li>
<li>将run workshop的任务传递给那些<code>有基础，而且有意愿接着run workshop的人</code></li>
</ol>
<p>2016年希望可以找到更多的<code>候选人</code>，并帮助他们成为更好的讲师，教练。</p>
<h2 id="总的感悟">总的感悟</h2>
<p>总体的感觉是很忙，各种事情千头万绪，没有了清晰的一个vision，也没有了指导，自身的发展方向也变得模糊起来。一部分原因可能是压力的方向变了，在项目上的单一的压力下总是可以找出一些事情来的，但是在项目之外，各种可见不可见的压力都慢慢浮现。对于这些隐形的，不可见的，但是又可以感受到的压力，需要认真思索对策，然后想办法搞定。</p>
<p>学习上有点“半瓶醋”的感觉，很多技术都接触了，但是不见得深入。缺乏空杯心态，这个是2016年希望自己能改进的地方。另一方面，希望在一个IT系统的架构层面有一些积累，以便在考虑项目的问题时，能够更加全面，而不至于陷入细节，只见树木，不见森林。</p>
<p>2016，当然还会很忙，只是希望忙的过程中可以多一些快乐。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>PM是大傻逼吗？</title>
      <link>https://icodeit.org/2015/07/is-project-manager-a-fool/</link>
      <pubDate>Tue, 07 Jul 2015 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2015/07/is-project-manager-a-fool/</guid>
      <description>一些背景故事 坊间流传着很多关于PM（Project Manager，项目经理）的笑话，在这些不无刻薄的笑话中，PM往往被描述成一个盲目的承诺客户需求变更，不了解实际情况而又喜欢指手画脚的专门坑开发的家伙。毋庸置疑，这些笑话当然是那些聪明的开发发明的（不过你得承认，在很多团队，这些笑话其实是实实在在每天都在发生着的）。
在智力工作中，对于开发的实际进度，开发速率等问题，具体着手做的人永远比在背后指手画脚的人更有发言权。软件开发正是一项智力活动，优秀的软件无法通过人力的堆积而产生。一个关于PM的经典的讽刺是：PM就是那些指望着9个女人在1个月内生出1个小孩的二货。从传统的意义上来说，这个笑话还真是一针见血。
我记得在加入ThoughtWorks不久的时候，私底下经常听到这种论调：PM基本就是项目上被人鄙视（当然大家不会表现的那么明显就是了）的角色，基本上负责团队建设去哪儿这种杂事儿就行了，团队的其他人员可以高度自治，并不需要被管理，项目就会如预期般按时交付。
这些论调在某些情况下可能是对的。但是如果在国内项目的这个上下文里，没有一个专业的PM来协助项目，控制需求，划定项目范围，与客户谈判等等，没有任何一个项目是可以真正成功交付的，指望高度自治的开发们来完成项目？咱们还是现实一些吧。
一个悲剧的事实是，开发人员往往都恃才傲物，有时还会带着一幅要来拯救世界的心态来做项目，这事实上和客户的期望，以及PM的期望是有很大出入的。在项目启动之初，PM会面临重重困难：首先，团队里的每个人都不好管，而且每个人都认为自己不需要被管理（当然这种想法在大部分时候都是错误的）；其次，PM需要和客户快速建立信任，并推动项目进入正轨；最后，往往留给PM自己的时间也非常有限，他们也需要学习大量的项目相关的上下文（业务上下文，人员关系，资源协调等）。
除了催进度，PM平时还干点啥？ 本质上开说，PM其实就是一个轮询器：识别所有的项目风险，然后不断跟进。项目风险可能是技术风险，比如某个技术上压根搞不定的问题。也可能资源风险，比如人手不够，或者开发者很多，但是没有足够的设计师协助，这些风险都会导致项目无法按照时间交付。一个客观事实是，所有项目都会变化，做完售前到需求分析结束之后，需求可能会发生巨大变化，如果还按照报价来做项目很可能会亏本。
PM的一个重要职责就是在项目之初将项目范围定下来，这个范围的划分非常依赖经验：划得少了团队得天天加班，累得跟狗一样，然后才能保证交付（据我的经验，虽然项目一般不会天天加班，但是总会有一些攻关，打补丁的事儿，最后还是会累成狗），划得多了客户不买单，意思是就这个小功能你要做两个月，绝对不行。PM需要协调这些不一致，还需要和销售，客户等方面不断谈判，写方案，排计划，简而言之，也是累跟狗一样（而且潜在的，还可能被那些天真幼稚的开发坑 — 开发经常会高估自己的开发速度，反正我还没遇到过低估的，你见过吗？）。
我们每天看到的PM干的最多的事情就是：元芳，那个接口怎么样了？什么时候能做完，有什么blocker？李柯，昨天说的代理的事情怎么样了？小波，高保真什么时候出？何方，我们周三下午要showcase，麻烦你订一下会议室吧……
除了写代码，Dev平时还干点啥？ 如果脱离开PM的角度，做为一个孤傲的开发，时常会觉得PM为什么老是问我进度，是不是怀疑我的能力？为什么监视我的工作？相信我，其实他才不想监视你。但是你设想一下：如果你不参与代码编写，每天只是看旁边的哥们写，你如何知道他实际的进度呢？而且众所周知，开发很难准确的更新自己的工作进度，而且遇到问题也很少积极主动的报告，通常都会自己埋头尝试解决。那么，轮询显然是一种成本最低，反馈最快的方法。
不主动更新进度是另外一个大问题，不过这个得单独说。关于更新进度，典型的的场景是：早上站会的时候，开发目光呆滞的盯着某个卡片，努力回忆其中的验收条件以及自己的当前进度，如果恰好脑海中的技术细节和卡片的描述在某个点上匹配了，他会迅速的告诉你，目前进展良好，今天上午应该就可以做完。开发在更新进度时，不是盲目乐观，就是跳进太细节的地方进行讨论，最后讨论的结果就是：跟没更新一样，除了浪费了10分钟时间。但是别忘了，PM会在15分钟之后再来轮询一次。
PM每周都需要汇总很多数字，比如本迭代完成的点数，剩余的点数，总体进度如何，有没有人有请假计划，遇到什么blocker，每个blocker的具体原因，每个风险点的最终日期是何时，等等等等。他肯定不能记住这些数字，所以可能一天之内向你询问数次。
PM的其他职责/技能 上边说到的其实只是描述PM的辛苦，而最微妙，最考验PM的是其“察言观色”的技能。这绝对是一个工作经验在10年之内完全无法获得的技能（而且是在中国的项目上工作10年）。比如，在showcase的时候，有个客户说，嗯，挺好，整个流程就是这样的，后续你们的UI是不是还会美化？如果你遇到这个情况，请问，这个客户是什么意思？
如果你能回答上这个问题（而不是提出问题），那说明你还离PM差十万八千里。成熟的PM会先判断，问这个问题的人是什么角色，以及他在系统中的话语权如何，还有其他人就此问题的反应如何等等因素，然后找到一个合适的答案。
PM另一个绝技是扯皮（不是贬义），开发会花一个下午（我是说10分钟）去跟客户讨论需求的范围吗？或者会为5个人天来讨价还价吗？我想开发大概会说，尼玛，找其他供应商吧，老子不伺候了。
一个项目的成功，需要多方合作，这里说的合作并不局限在甲方和乙方之间，即使乙方的团队之中，也需要很紧密的合作。比如项目经理和开发，设计师之间的合作。如果仅仅从开发的角度来看，PM有时候看起来就是和客户站在一起来整开发的一样，比如催进度，过分保守的估算人天（导致团队加班赶工）。PM需要释放团队中的负面情绪，保证团队士气，还需要他做一些开发不屑于做的琐碎的事情。
设身处地，替他人着想 本质来来说，每个项目都是一次生意。在去掉那些繁杂的流程和形式之后，做一个项目和你去菜市场买菜其实并无二致。举个例子，根据传统，软件开发界特别喜欢找建筑行业做类比，我也找个建筑方面例子。装修房子的时候，我们会要求施工方提供图纸（水电改造，基本设计等），按期交付（确定工期），同时会界定项目范围（比如刷墙，贴地砖，吊顶，封阳台等等），会要求工人按时来上班，正常出勤，认真工作，直到项目结束。过程中我们还会讨价还价，比如捎带着把栏杆拆除，捎带着敲掉一面隔离墙等等。在过程中，我们还会敲敲地砖，检查过门石，检查吊顶，测试水电等等。作为甲方，这些活动相信没有人会觉得过分。
但是一旦我们做乙方，也就是施工方的时候，情况就全变了。比如客户要求打卡，有人会觉得不爽，客户要求代码review，有人会觉得不爽，要求代码有设计文档，有人会觉得不爽，要求设计有多个备选方案，有人会觉得不爽。大多数情况下，这都是虚无缥缈的虚荣在作祟，这种情况所在多有，不过还不致命。一旦涉及到讨价还价（不是商务上的讨价还价，而是和客户就工作量达不成一致，或者就某个技术方案达不成一致之后），开发全部歇菜，一言不合，转身就走，压根不具备讨价换件的能力，这样还怎么做生意啊？设身处地想一下，如果你是甲方，当提出了一些合理的要求（比如需要一方提供验收标准，通过验收测试等），结果施工方还一脸的“我不跟你说了，你就是以大傻B”，你能乐意吗？
如何合作？ 说了这么多，这两种角色在同一个项目上要如何合作呢？我想，作为开发来说，有这样几点可能：
首先，理解PM的工作。在很多时候，开发会有莫名其妙的优越感（其实每个角色都会有了，比如销售看不上技术人员，技术Lead看不上PM等等），主要原因其实是坐井观天，对其他角色的辛苦和工作不清楚。然后错误的认为别人的工作都很low。
之前听一个同事讲过一个小session，里面有一点我印象非常深刻：不要因为一个人不会某个技术而鄙视他。就好比你不应该因为不会弹钢琴，而被一个会弹钢琴的人鄙视一样。道理很简单，但是开发在长期的“宅”生涯或者坐井观天中，进化出了这种非理性的观点：如果一个人连vim（此处的vim可以换成任何其他技术）都不会，就压根不足以谈人生。
其次，学习如何报告进度。PM催你的根本原因是进度不明确，如果每一个潜在的风险都清楚的显示着进度，而且有明确的负责人，PM就会降低轮询的频率。这需要开发经过刻苦的练习才能达到：
 站会前自己花3分钟整理一下昨天做的工作 根据story的验收条件（最好有和BA/QA一起的讨论需求），进行合理的任务划分（tasking技能） 可以借助便签纸等工具，帮助自己明确进度（划分了5个子任务，昨天完成了3个，那么可以粗略的估计为60%）  再次，合理估算。有些时候，新人（来自于传统管理环境的新人）可能会误以为PM是一个管理的角色，或者处于某些考虑会在PM询问进度时做出一些错误的回答。比如PM在迭代启动会议上是问这个迭代我们有没有可能做完所有计划内的任务，作为一个负责任的开发，你需要在第一时间指出那些“非理性”的期望，以便PM进行更加准确的计划。
 明确告诉PM，有哪些需求是不可能按时交付的，PM会根据实际情况来重新定计划，并和客户确认 明确告诉PM一些可能的风险，团队整体对交付负责，而不是PM，或者开发  按照经验，项目从来就不会按照计划进行，在做好一个粗略的计划之后，PM的职责更多的是进行动态调整。所以团队内部至少需要保持信息的流通，虽然可能短期来看可能会影响开发速度，但是从整体上来看，可以减少很多不必要的浪费。
简而言之，要站在别人的角度考虑问题：如果换做是你，你会怎么做？</description>
      <content:encoded><![CDATA[<h3 id="一些背景故事">一些背景故事</h3>
<p>坊间流传着很多关于PM（Project Manager，项目经理）的笑话，在这些不无刻薄的笑话中，PM往往被描述成一个盲目的承诺客户需求变更，不了解实际情况而又喜欢指手画脚的专门坑开发的家伙。毋庸置疑，这些笑话当然是那些聪明的<strong>开发</strong>发明的（不过你得承认，在很多团队，这些笑话其实是实实在在每天都在发生着的）。</p>
<p>在智力工作中，对于开发的实际进度，开发速率等问题，具体着手做的人永远比在背后指手画脚的人更有发言权。软件开发正是一项智力活动，优秀的软件无法通过人力的堆积而产生。一个关于PM的经典的讽刺是：PM就是那些指望着9个女人在1个月内生出1个小孩的二货。从传统的意义上来说，这个笑话还真是一针见血。</p>
<p><img loading="lazy" src="/images/2015/07/keep-calm-i-m-the-project-manager-resized.png" type="" alt="project manager, 来源:http://sd.keepcalm-o-matic.co.uk/i/keep-calm-i-m-the-project-manager.png"  /></p>
<p>我记得在加入ThoughtWorks不久的时候，私底下经常听到这种论调：PM基本就是项目上被人鄙视（当然大家不会表现的那么明显就是了）的角色，基本上负责<strong>团队建设</strong>去哪儿这种杂事儿就行了，团队的其他人员可以高度自治，并不需要被管理，项目就会如预期般按时交付。</p>
<p>这些论调在某些情况下可能是对的。但是如果在国内项目的这个上下文里，没有一个专业的PM来协助项目，控制需求，划定项目范围，与客户谈判等等，没有任何一个项目是可以真正成功交付的，指望<em>高度自治</em>的开发们来完成项目？咱们还是现实一些吧。</p>
<p>一个悲剧的事实是，开发人员往往都恃才傲物，有时还会带着一幅要来拯救世界的心态来做项目，这事实上和客户的期望，以及PM的期望是有很大出入的。在项目启动之初，PM会面临重重困难：首先，团队里的每个人都不好管，而且每个人都认为自己不需要被管理（当然这种想法在大部分时候都是错误的）；其次，PM需要和客户快速建立信任，并推动项目进入正轨；最后，往往留给PM自己的时间也非常有限，他们也需要学习大量的项目相关的上下文（业务上下文，人员关系，资源协调等）。</p>
<h3 id="除了催进度pm平时还干点啥">除了催进度，PM平时还干点啥？</h3>
<p>本质上开说，PM其实就是一个轮询器：识别所有的项目风险，然后不断跟进。项目风险可能是技术风险，比如某个技术上压根搞不定的问题。也可能资源风险，比如人手不够，或者开发者很多，但是没有足够的设计师协助，这些风险都会导致项目无法按照时间交付。一个客观事实是，所有项目都会变化，做完售前到需求分析结束之后，需求可能会发生巨大变化，如果还按照报价来做项目很可能会<strong>亏本</strong>。</p>
<p>PM的一个重要职责就是在项目之初将项目范围定下来，这个范围的划分非常依赖经验：划得少了团队得天天加班，累得跟狗一样，然后才能保证交付（据我的经验，虽然项目一般不会天天加班，但是总会有一些攻关，打补丁的事儿，最后还是会累成狗），划得多了客户不买单，意思是就这个小功能你要做两个月，绝对不行。PM需要协调这些不一致，还需要和销售，客户等方面不断谈判，写方案，排计划，简而言之，也是累跟狗一样（而且潜在的，还可能被那些天真幼稚的开发坑 — 开发经常会高估自己的开发速度，反正我还没遇到过低估的，你见过吗？）。</p>
<p>我们每天看到的PM干的最多的事情就是：元芳，那个接口怎么样了？什么时候能做完，有什么blocker？李柯，昨天说的代理的事情怎么样了？小波，高保真什么时候出？何方，我们周三下午要showcase，麻烦你订一下会议室吧……</p>
<p><img loading="lazy" src="/images/2015/07/pm-resized.png" type="" alt="pm"  /></p>
<h3 id="除了写代码dev平时还干点啥">除了写代码，Dev平时还干点啥？</h3>
<p>如果脱离开PM的角度，做为一个孤傲的开发，时常会觉得PM为什么老是问我进度，是不是怀疑我的能力？为什么监视我的工作？相信我，其实他才不想监视你。但是你设想一下：如果你不参与代码编写，每天只是看旁边的哥们写，你如何知道他实际的进度呢？而且众所周知，开发很难准确的更新自己的工作进度，而且遇到问题也很少积极主动的报告，通常都会自己埋头尝试解决。那么，轮询显然是一种成本最低，反馈最快的方法。</p>
<p>不主动更新进度是另外一个大问题，不过这个得单独说。关于更新进度，典型的的场景是：早上站会的时候，开发目光呆滞的盯着某个卡片，努力回忆其中的验收条件以及自己的当前进度，如果恰好脑海中的技术细节和卡片的描述在某个点上匹配了，他会迅速的告诉你，目前进展良好，今天上午应该就可以做完。开发在更新进度时，不是盲目乐观，就是跳进太细节的地方进行讨论，最后讨论的结果就是：跟没更新一样，除了浪费了10分钟时间。但是别忘了，PM会在15分钟之后再来轮询一次。</p>
<p>PM每周都需要汇总很多数字，比如本迭代完成的点数，剩余的点数，总体进度如何，有没有人有请假计划，遇到什么blocker，每个blocker的具体原因，每个风险点的最终日期是何时，等等等等。他肯定不能记住这些数字，所以可能一天之内向你询问数次。</p>
<h3 id="pm的其他职责技能">PM的其他职责/技能</h3>
<p>上边说到的其实只是描述PM的辛苦，而最微妙，最考验PM的是其“察言观色”的技能。这绝对是一个工作经验在10年之内完全无法获得的技能（而且是在中国的项目上工作10年）。比如，在showcase的时候，有个客户说，嗯，挺好，整个流程就是这样的，后续你们的UI是不是还会美化？如果你遇到这个情况，请问，这个客户是什么意思？</p>
<p>如果你能回答上这个问题（而不是提出问题），那说明你还离PM差十万八千里。成熟的PM会先判断，问这个问题的人是什么角色，以及他在系统中的话语权如何，还有其他人就此问题的反应如何等等因素，然后找到一个合适的答案。</p>
<p>PM另一个绝技是扯皮（不是贬义），开发会花一个下午（我是说10分钟）去跟客户讨论需求的范围吗？或者会为5个人天来讨价还价吗？我想开发大概会说，尼玛，找其他供应商吧，老子不伺候了。</p>
<p>一个项目的成功，需要多方合作，这里说的合作并不局限在甲方和乙方之间，即使乙方的团队之中，也需要很紧密的合作。比如项目经理和开发，设计师之间的合作。如果仅仅从开发的角度来看，PM有时候看起来就是和客户站在一起来整开发的一样，比如催进度，过分保守的估算人天（导致团队加班赶工）。PM需要释放团队中的负面情绪，保证团队士气，还需要他做一些开发不屑于做的琐碎的事情。</p>
<h3 id="设身处地替他人着想">设身处地，替他人着想</h3>
<p>本质来来说，每个项目都是一次生意。在去掉那些繁杂的流程和形式之后，做一个项目和你去菜市场买菜其实并无二致。举个例子，根据传统，软件开发界特别喜欢找建筑行业做类比，我也找个建筑方面例子。装修房子的时候，我们会要求施工方提供图纸（水电改造，基本设计等），按期交付（确定工期），同时会界定项目范围（比如刷墙，贴地砖，吊顶，封阳台等等），会要求工人按时来上班，正常出勤，认真工作，直到项目结束。过程中我们还会讨价还价，比如捎带着把栏杆拆除，捎带着敲掉一面隔离墙等等。在过程中，我们还会敲敲地砖，检查过门石，检查吊顶，测试水电等等。作为甲方，这些活动相信没有人会觉得过分。</p>
<p>但是一旦我们做乙方，也就是施工方的时候，情况就全变了。比如客户要求打卡，有人会觉得不爽，客户要求代码review，有人会觉得不爽，要求代码有设计文档，有人会觉得不爽，要求设计有多个备选方案，有人会觉得不爽。大多数情况下，这都是虚无缥缈的虚荣在作祟，这种情况所在多有，不过还不致命。一旦涉及到讨价还价（不是商务上的讨价还价，而是和客户就工作量达不成一致，或者就某个技术方案达不成一致之后），开发全部歇菜，一言不合，转身就走，压根不具备讨价换件的能力，这样还怎么做生意啊？设身处地想一下，如果你是甲方，当提出了一些合理的要求（比如需要一方提供验收标准，通过验收测试等），结果施工方还一脸的“我不跟你说了，你就是以大傻B”，你能乐意吗？</p>
<h3 id="如何合作">如何合作？</h3>
<p>说了这么多，这两种角色在同一个项目上要如何合作呢？我想，作为开发来说，有这样几点可能：</p>
<p>首先，理解PM的工作。在很多时候，开发会有莫名其妙的优越感（其实每个角色都会有了，比如销售看不上技术人员，技术Lead看不上PM等等），主要原因其实是<strong>坐井观天</strong>，对其他角色的辛苦和工作不清楚。然后错误的认为别人的工作都很low。</p>
<p>之前听一个同事讲过一个小session，里面有一点我印象非常深刻：不要因为一个人<strong>不会某个技术</strong>而鄙视他。就好比你不应该因为不会弹钢琴，而被一个会弹钢琴的人鄙视一样。道理很简单，但是开发在长期的“宅”生涯或者坐井观天中，进化出了这种非理性的观点：如果一个人连vim（此处的vim可以换成任何其他技术）都不会，就压根不足以谈人生。</p>
<p>其次，学习如何报告进度。PM催你的根本原因是进度不明确，如果每一个潜在的风险都清楚的显示着进度，而且有明确的负责人，PM就会降低轮询的频率。这需要开发经过刻苦的练习才能达到：</p>
<ul>
<li>站会前自己花3分钟整理一下昨天做的工作</li>
<li>根据story的验收条件（最好有和BA/QA一起的讨论需求），进行合理的任务划分（tasking技能）</li>
<li>可以借助便签纸等工具，帮助自己明确进度（划分了5个子任务，昨天完成了3个，那么可以粗略的估计为60%）</li>
</ul>
<p><img loading="lazy" src="/images/2015/07/tasking-resized.png" type="" alt="tasking"  /></p>
<p>再次，合理估算。有些时候，新人（来自于传统管理环境的新人）可能会误以为PM是一个管理的角色，或者处于某些考虑会在PM询问进度时做出一些错误的回答。比如PM在迭代启动会议上是问这个迭代我们有没有可能做完所有计划内的任务，作为一个负责任的开发，你需要在第一时间指出那些“非理性”的期望，以便PM进行更加准确的计划。</p>
<ul>
<li>明确告诉PM，有哪些需求是不可能按时交付的，PM会根据实际情况来重新定计划，并和客户确认</li>
<li>明确告诉PM一些可能的风险，<strong>团队整体</strong>对交付负责，而不是PM，或者开发</li>
</ul>
<p>按照经验，项目从来就不会按照计划进行，在做好一个粗略的计划之后，PM的职责更多的是进行动态调整。所以团队内部至少需要保持信息的流通，虽然可能短期来看可能会影响开发速度，但是从整体上来看，可以减少很多不必要的浪费。</p>
<p>简而言之，要站在别人的角度考虑问题：<strong>如果换做是你，你会怎么做？</strong></p>
]]></content:encoded>
    </item>
    
    <item>
      <title>我们真的缺前端工程师吗</title>
      <link>https://icodeit.org/2015/06/do-we-really-short-for-front-end-developer/</link>
      <pubDate>Sun, 14 Jun 2015 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2015/06/do-we-really-short-for-front-end-developer/</guid>
      <description>前言 这两天在好几个地方都看到了一篇关于为什么整个互联网行业都缺前端工程师？的文章，文章本身是去年的，中心思想是：其实我们并不缺前端工程师，我们缺的是优秀的前端工程师。我还是比较同意作者观点的，不过略有意犹未尽的感觉。于是我结合自己的经验，也来聊一下这个话题：我们真的缺前端工程师吗？
These walls are kind of funny like that. First you hate them, then you get used to them.Enough time passed, get so you depend on them. That’s institutionalising.
传统软件公司划分开发者的方式下，在前端部门的程序员永远不会去读缓存数据部分的代码，设计师也不太可能去和开发坐在一起，开发也不知道软件最终软件会以何种方式部署在服务器上。
什么是“前端”工程师 我在招聘广告和办公室的一些对话中，听到了一个新的角色：UI Dev，事实上我在知乎上还回答过一个关于ThoughtWorks的UI Dev的问题。简而言之，UI Dev可以快速的把设计师的作品实现为HTML/CSS/JavaScript代码。
如果按照这个标准，我觉得UI Dev对自己的要求太低了。毕竟要学会HTML/CSS实现mockup并不困难，但是成为一名前端工程师则需要掌握更多的知识：
 会用PS来进行图片的处理（比如切图，微调等） 用HTML/CSS实现mockup（可能还有SASS/LESS等工具） 熟悉JavaScript（比如前端的MVVM框架，客户端模板） 前端开发的工作流程（代码检查，精简化，模块化CSS，LiveReload，调试） 编写测试（静态检查，单元测试） 跨浏览器、跨设备的解决方法（不同分辨率，不同厂商） 会根据项目的特点选择不同的前端技术栈（移动端，Web站点，响应式设计等）  在有了基础的HTML/CSS/JS技能之后，你会尝试做的更好：
 如何更高效的操作DOM 如何将CSS写的更加清晰易懂 如何编写更加易于维护的代码（更有意义的单元测试） 如何组织大型的项目结构，模块化，组件化等等  这些要求事实上已经不那么容易做到了。它可能会花费你2到3年时间来完全掌握。但是2到3年之后，即便你已经成为了一个“合格的”前端工程师，这也还远远不够。在现实世界中，一个软件产品除了前端，还有非常广阔的空间，还有很多有趣的东西值得学习：
 HTTP协议本身（缓存，鉴权） Web容器/HTTP服务器如何工作 无状态的Web应用的工作原理（如何让网站正确地运行在集群上） 动态，静态内容如何分离部署（反向代理配置） 安全机制如何配置 监控机制如何配置  有了这些，也算是有点端到端的意思了。这时你也已经不是一个“纯前端”工程师了，系统中的大部分问题你都可以搞定，不过日常工作中可能更多的职责还是做前端的开发。但是这些还不够，软件除了交付之外，还有一些非功能性的需求：
 端到端测试（UI测试，比如selenium server/web driver） devops（比如数据库环境，测试服务器，CI服务器的自动化provision） 基本的UI设计原则（在某些页面确实的情况下，根据系统的已有UI做设计） 数据库性能优化 性能测试  不过这些还只是我对于Web开发这个领域的总结。其他领域，比如大数据，机器学习，GIS，图像/视频处理等等。</description>
      <content:encoded><![CDATA[<h3 id="前言">前言</h3>
<p>这两天在好几个地方都看到了一篇关于<a href="http://chuansong.me/n/1369941">为什么整个互联网行业都缺前端工程师？</a>的文章，文章本身是去年的，中心思想是：其实我们并不缺前端工程师，我们缺的是优秀的前端工程师。我还是比较同意作者观点的，不过略有意犹未尽的感觉。于是我结合自己的经验，也来聊一下这个话题：<strong>我们真的缺前端工程师吗？</strong></p>
<p><code>These walls are kind of funny like that. First you hate them, then you get used to them.Enough time passed, get so you depend on them. That’s institutionalising.</code></p>
<p>传统软件公司划分开发者的方式下，在前端部门的程序员永远不会去读缓存数据部分的代码，设计师也不太可能去和开发坐在一起，开发也不知道软件最终软件会以何种方式部署在服务器上。</p>
<h3 id="什么是前端工程师">什么是“前端”工程师</h3>
<p>我在招聘广告和办公室的一些对话中，听到了一个新的角色：UI Dev，事实上我在知乎上还回答过一个<a href="http://www.zhihu.com/question/30170650">关于ThoughtWorks的UI Dev的问题</a>。简而言之，UI Dev可以快速的把设计师的作品实现为HTML/CSS/JavaScript代码。</p>
<p><img loading="lazy" src="/images/2015/06/website-development-resized.png" type="" alt="front-end development"  /></p>
<p>如果按照这个标准，我觉得UI Dev对自己的要求太低了。毕竟要学会HTML/CSS实现mockup并不困难，但是成为一名前端工程师则需要掌握更多的知识：</p>
<ul>
<li>会用PS来进行图片的处理（比如切图，微调等）</li>
<li>用HTML/CSS实现mockup（可能还有<a href="http://sass-lang.com/">SASS</a>/<a href="http://lesscss.org/">LESS</a>等工具）</li>
<li>熟悉JavaScript（比如前端的MVVM框架，客户端模板）</li>
<li>前端开发的工作流程（代码检查，精简化，模块化CSS，LiveReload，调试）</li>
<li>编写测试（静态检查，单元测试）</li>
<li>跨浏览器、跨设备的解决方法（不同分辨率，不同厂商）</li>
<li>会根据项目的特点选择不同的前端技术栈（移动端，Web站点，响应式设计等）</li>
</ul>
<p>在有了基础的HTML/CSS/JS技能之后，你会尝试做的更好：</p>
<ul>
<li>如何更高效的操作DOM</li>
<li>如何将CSS写的更加清晰易懂</li>
<li>如何编写更加易于维护的代码（更有意义的单元测试）</li>
<li>如何组织大型的项目结构，模块化，组件化等等</li>
</ul>
<p>这些要求事实上已经不那么容易做到了。它可能会花费你2到3年时间来完全掌握。但是2到3年之后，即便你已经成为了一个“合格的”前端工程师，这也还远远不够。在现实世界中，一个软件产品除了前端，还有非常广阔的空间，还有很多有趣的东西值得学习：</p>
<ul>
<li>HTTP协议本身（缓存，鉴权）</li>
<li>Web容器/HTTP服务器如何工作</li>
<li>无状态的Web应用的工作原理（如何让网站正确地运行在集群上）</li>
<li>动态，静态内容如何分离部署（反向代理配置）</li>
<li>安全机制如何配置</li>
<li>监控机制如何配置</li>
</ul>
<p>有了这些，也算是有点端到端的意思了。这时你也已经不是一个“纯前端”工程师了，系统中的大部分问题你都可以搞定，不过日常工作中可能更多的职责还是做前端的开发。但是这些还不够，软件除了交付之外，还有一些非功能性的需求：</p>
<ul>
<li>端到端测试（UI测试，比如<a href="http://www.seleniumhq.org/">selenium server</a>/web driver）</li>
<li>devops（比如数据库环境，测试服务器，CI服务器的自动化provision）</li>
<li>基本的UI设计原则（在某些页面确实的情况下，根据系统的已有UI做设计）</li>
<li>数据库性能优化</li>
<li>性能测试</li>
</ul>
<p><del>不过这些还只是我对于Web开发这个领域的总结。其他领域，比如大数据，机器学习，GIS，图像/视频处理等等。</del></p>
<p>这时候，你才能算是一个严格意义上的“前端”工程师。不从系统的角度来思考，不真正做一些后端开发/配置，并不能算是前端工程师，或者可以被称为<em>偏前端</em>工程师（partial frontend developer）。但是即使称为上边这样的“前端工程师”，我想这离一个优秀的工程师还是有<strong>很大差距</strong>的。</p>
<p>我跟一位<a href="http://www.caicaiwan.com/">设计师同事</a>聊过这个问题：</p>
<p><code>Dev眼中的世界是这样的，从墙上（物理的或者电子的）上找到一些卡片（story卡或者需求文档说明书），然后撸袖子开干，干的过程中有很多自以为是的理解，同样有一些自以为是的牛逼实践（TDD啊，自动化啊），最后功能做完，大功告成，然后接着做下一个卡片。传统的Dev，或者苦逼屌丝程序员的世界就是这样的：需求从哪儿来，不知道；做完之后谁来负责质量，不知道；最终上线的时候怎么发布，不知道；线上有问题了怎么办，不知道。</code></p>
<p>以及</p>
<p><code>在ThoughtWorks，Dev的工作有了很大的变化，一个最明显的变化是边界的模糊。比如很多项目都不设QA角色，所有人都对质量负责，都做测试，也有OPs角色，但是大部分非生产环境都是Dev自己发布。也就是说，软件/项目生命周期中的大部分实践我们都能涉足，而且可以带来改进，提升效率。但是这只是往下游（从开发，到测试，到部署，到运维），反过来看上游，比如需求从哪儿来，Dev还是不知道。这毫无疑问是一个令人沮丧的事实，因为这需求的产生才是核心，也就是我昨天跟你聊的：一个idea如何变成一个可视化的原型，然后进一步演进为项目原型？</code></p>
<p>开发工作不应该仅仅局限在编码上，作为开发者/工程师，应该尽可能的多了解一些上下文：比如我们的项目最终是给谁用的，需求从何而来，项目是如何部署在线上的等等。</p>
<p><img loading="lazy" src="/images/2015/06/software-life-cycle-resized.png" type="" alt="software life cycle"  /></p>
<p>简而言之，开发者视野应该放开开阔一些。不要将自己局限在某种角色上，不但不要局限在前端/后端开发上，压根就不要局限在开发这种角色本身上，你在系统中，可以是设计师，还可以是业务分析师。虽然不一定最终要你去转行做BA，或者UX，但是更广阔的视野可以使你更加高效的发挥自己的作用，也可以在和别的角色互动式，快速的了解上下文。</p>
<p>我所理解的，前端不一定要熟知所有这些知识和技能，但是<strong>一定不要认为自己做好了前端的一亩三分地就足够了</strong>，不要给自己设限。跨界会给你带来难以估量的好处，一个角色做久了，难免会产生一些盲点。这时候，换个视角，从其他角色的角度来看待你的工作，又会有很多新的发现。而且不仅如此，很可能你会发现之前很麻烦，很难搞定的事情，在新的方法/视角下变得很容易。</p>
<h3 id="我的故事">我的故事</h3>
<h4 id="其实我是一名后端开发">其实，我是一名后端开发</h4>
<p>工作之后，我在很长一段时间是专注于“非前端”的领域。和很多刚入行的新人一样，我对计算机能触及的几乎一切领域都感兴趣：语言解释器，人工智能（遗传算法，隐式马尔科夫模型，自动纠错，模式识别），嵌入式开发，图形处理，操作系统的进程调度，进程间通信，多线程模型，各种脚本语言（python，ruby，JavaScript等等），另外，日常开发流程中的一些工具的定制化也会花去我很多的时间，比如如何配置vim，写几个小脚本来和编辑器做集成等等。更别说那些令人一听就觉得激动的编程范式：面向对象，基于消息总线，函数式编程等等。如果你感兴趣，可以看看我<a href="http://abruzzi.iteye.com/">几年前的博客</a>。</p>
<p>我的上一家公司的产品是一个省级电网的收费/计费系统（电其实和我们在超市里购买的其他生活用品一样，也是一种商品）。我在那里工作了差不多两年，日常的开发方式就是ssh登陆到RHEL（Redhat Enterprise Linux）服务器上，用vim（当然有一堆的vim插件）开发C代码，调试器是gdb（对，就是那个很牛逼，但是对新手特别不友好的gdb）。</p>
<p>我们用C语言给Apache的httpd写了一个扩展module，大约相当于现在rack里的中间件，这个module要和后端的一个要复杂的多的模块通信，其中不但涉及网络通信，还有*nix管道，缓冲，并发等等考虑。在这两年里，我几乎没有碰过任何的Web界面上的东西（除了用php写了一两百行的页面之外）。</p>
<p>在加入这家公司之前，我在一家用Java做报表的公司工作，技术栈为J2EE。其中有一些前端的工作，但是并不很多，而且说实话，我当时有些看不太上这些技术。HTML/CSS在我心目中的地位比线程池，语言解析等差远了，所以我也没有认真地去系统学习。</p>
<p>在加入ThoughtWorks之前，在“前端”方面，唯一算是比较擅长的也不过是写JavaScript，而且对于前端的MVVM框架，双向绑定，模块化等高级货都没听过。且不能论HTML/CSS的最佳实践，连根据设计稿做出一个静态页面的的能力也不具备。我之前有一点JSP/HTML经验，而CSS经验也并没有超出如何画一个细线表格的范畴。换句话说，我的前端（特别是HTML/CSS）是最近才学会的。</p>
<h4 id="thoughtworks的开发">ThoughtWorks的开发</h4>
<p>在ThoughtWorks，很多团队是按照feature团队来组建的。相对于传统的component团队（按部门划分，比如研发组，测试组，设计组等，每个组还有可能会再细分成如用户调研，流程设计，视觉设计等等），feature团队里配备了软件开发过程中需要的几乎所有角色：业务分析，测试工程师，开发工程师，设计师（设计师一般不会常驻），有的团队还有项目经理的角色。</p>
<p>在feature团队里，你可以很容易看到不同的角色是如何工作的，很多时候，开发会和设计师一起来调整颜色，排版，布局，也可能和测试一起编写自动化测试用例，showcase等。也就是说，角色之间的藩篱在淡化，而就开发这一种角色而言，对于前端/后端的区分也会显得非常模糊，因为需求划分之后的story（敏捷开发中的一个术语，其实就是需求的一种展现方式）是端到端的，比如一个商品列表展示的story，会包括</p>
<ul>
<li>数据库的表结构</li>
<li>访问数据库的<a href="https://en.wikipedia.org/wiki/Object-relational_mapping">ORM</a>部分，</li>
<li>使用ORM的业务逻辑service</li>
<li>响应客户端的controller（消费JSON或者XML的HTTP接口）</li>
<li>发送请求，处理响应的JavaScript代码</li>
<li>和设计稿一致的CSS样式</li>
</ul>
<p>而且在这个过程中还会涉及到一些外围的工具</p>
<ul>
<li>虚拟机环境准备</li>
<li>数据库连接</li>
<li>自动化测试（单元测试，集成测试，可能还有UI测试）</li>
<li>数据库迁移脚本</li>
</ul>
<p>在这个过程中，开发者需要掌握和开发过程相关的一切实践中的一切工具.</p>
<p>在我的<a href="http://www.thoughtworks.com/">ThoughtWorks</a>的第一个项目中，我是以Java开发工程师角色加入的，下项目的时候，我学会了自动化provision，<a href="https://cucumber.io/">cucumber</a>测试工具，Rails，<a href="https://gradle.org/">gradle</a>（没错，我之前用Java都是用IDE构建的，在Linux世界我用make），<a href="http://jasmine.github.io/2.0/introduction.html">jasmine</a>测试工具，<a href="http://backbonejs.org/">Backbone.js</a>，haml.js。</p>
<p>第二个项目的时候，我是以前端工程师角色加入，下项目的时候，我学会了nginx配置缓存、负载均衡服务器，<a href="http://gatling.io/">gatling</a>测试工具，Hadoop/Spark等的集群配置，还有一些和项目相关的<a href="http://icodeit.org/2014/04/intro-map-gis/">GIS（地理信息系统）</a>的技术栈，前后端分离策略等。</p>
<p>第三个项目我是以Java开发工程师角色加入的，下项目的时候，我学会了如何做性能测试，如何建立<a href="http://dashing.io/#setup">一个漂亮的Dashboard</a>（可以用来展现CI等），而且在业余时间系统的学习了CSS3和HTML5，将之前零敲碎打的那些知识串起来，这些总结做了几次内部培训后，还整理成了<a href="https://selfstore.io/products/348">一本电子书</a>。</p>
<p>第四个项目我又变成了一个前端工程师，但是这个项目有意思的地方是跟mobile相关，于是页面性能，体验又变成了一个重点，下项目的时候，我对无状态的Web应用，session的持久化，<a href="https://www.gitbook.com/book/juntao/3-web-designs-in-3-weeks/details">CSS3的动画</a>，用Backbone.js组织多页面的方式等等又有了新的理解。</p>
<p>如果这些经历造成了你觉得我很牛的错觉，那我应该道歉。我觉得自己勉强可以算是个合格的程序员：对学习保持着热情，对解决问题保持着热情，仅此而已。在项目上，如果我发现了问题，我就想办法解决，如果属于知识欠缺，那我就会去学习。我还远远没有到达精通这些技术的地步，但是在工程实践领域，根据<a href="https://en.wikipedia.org/wiki/Pareto_principle">80/20原则</a>，这些粗浅的知识足以解决80%的问题，而另外的20%，我们才真正需要一个专家来帮忙。也就是说，团队里需要有一个能解决20%的问题的前端工程师，而其他的80%的前端工作，应该可以被其他所有的开发完成，对于后端开发也是一样。</p>
<p><del>尝试从系统级别去解决一个问题，而不是将问题抛给另外一个角色（后端工程师，UX或者QA）</del></p>
<p>我是一个Dev，但是花了一些时间来学习界面设计，这里是我从设计到实现的两个小页面：</p>
<p><img loading="lazy" src="/images/2015/06/ilearn-resized.png" type="" alt="ilearn"  /></p>
<p><img loading="lazy" src="/images/2015/06/lightweight-resized.png" type="" alt="lightweight"  /></p>
<h3 id="总结">总结</h3>
<p>我们缺的从来都不是前端/后端工程师，而是<strong>工程师</strong>(或者那些会系统思考，并总是想着解决问题的人)。角色划分在大的机构内可能是有意义的，就像历史上工厂里，工人被分为车工，钳工，木工，电工。但是这种模式在软件开发中未必好用，<strong>具体而微</strong>的小团队可能更具竞争力。而在一个个的小团队中，再细分前端后端就显得比较滑稽了。团队中的每个成员都应该具备基本的端到端能力（不仅仅是开发，更应该是具有业务上下文，即每个人都清楚我们要交付的最终产品是什么，以及这个产品是如何帮助最终用户的），每个成员也都需要为最终的交付物负责，而不是为自己的职责负责。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>在Thoughtworks我们如何做培训</title>
      <link>https://icodeit.org/2015/01/how-we-do-training-in-thoughtworks/</link>
      <pubDate>Sun, 25 Jan 2015 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2015/01/how-we-do-training-in-thoughtworks/</guid>
      <description>ThoughtWorks内部培训 对新人的培训是每个企业都绕不开的一个话题，企业当然想要每个新人都能直接独当一面，最好可以直接上项目贡献自己的价值。但是从经验来看，所有新人到一个新环境都需要学习很多不同的新东西（新技术，框架，语言，工作方式等等），而每个企业对于培训新人都有各种各样的策略，比如老人带新人，比如扔到项目上让新人自己学。
在ThoughtWorks，我们有着丰富的培训方式，有面向社招的，有面向毕业生的，有民间自发的，有官方组织的，有内部的，也有面向社区的。
TWU TWU全称ThoughtWorks University，面向毕业生，入职之后的第一堂课。TWU的地点设在印度，之前在班加罗尔，后来改到了普内。每一期5周，学生们需要和和全球其他国家地区的同学一起，一般会尽量将各个地区的学生打乱安排，尽量让学生体会多元化的文化，培训内容设计公司文化，软件开发方法论，敏捷开发（Project SImulation）实践等，同时还需要保证学生有足够的代码练习机会。
我在2013年作为讲师参加了一起TWU，对我自己的帮助也非常大，在和来自不同地区的讲师一起备课，学习中学习到了很多的东西，之前似是而非的一些概念也得到了纠正。
TWI TWI全称ThoughtWorks Immersion，面向有经验的社招同事，主要涉及的内容为公司文化（合作，沟通），专业服务（如何专业的解决客户的问题），软件开发流程，敏捷开发方法论等。
我在2012年时参加过TWI，并整理了几篇相关文章，可以参考这里，这里还有这里。
Session Office局限在ThoughtWorks办公室之内，内容随意，参加不参加随意，可以随时加入或随时离开。虽然内容没有限制，但是大多数时候分享的都是技术主题。比如自动化部署，自动测试，Spring 4，Ruby中的构建工具等等。
Sessoin的形式是主讲者找一个自己感兴趣的主题，一个人讲，其他参与者听，鼓励互动。时间一般控制在一个小时以内，所以一般选择在中午饭的时候，有的session会给大家订饭，一边吃一边听。
虽然大部分Sessoin的主题是技术相关的，但是并不局限于此。比如旅游见闻，历史，财务，摄影等等，都可以分享，有时候这些趣味性的Session的参与者更多。
WorkShop Office之内，内容随意，以动手为主，讲解为辅。
 HTML/CSS Testable JavaScript 设计工作坊 OO BootCamp Ruby BootCamp  一般来说，Workshop都会组成一个系列，通常会占用几天到几周不等。参与者需要带上电脑，在课堂上进行练习之外，课后还会有一些练习。
3周3页面和可测试的JavaScript是我去年做的两个Workshop。由于Workshop会在下班后或者中午的休息时间，公司会为每个参与者订饭，以节省时间。
郑大晔校 面向刚刚得到offer的毕业生，在上项目之前，我们希望学生的基本技术达到特定的水平，因此设置了一系列的练习。包括
 编程基础 开发流程 工作方式 公司文化  等等。郑大晔校的周期为每周一次，一次一天。涉及的内容会与大多数项目上的要求一致，比如西安office的Java/Ruby项目居多，我们的课程安排就会涉及到Java/Ruby方面。当然，各种软技能如工作方式也会在课程中涉及，尽量的寓教于乐。
每期郑大晔校大概会有10周，学生入职之后有的会直接去TWU，有的则会在项目上工作一段时间再去TWU。
组内培训 各个组内自行组织，并不要求其他同事参加。比如某个项目需要一些docker的知识，或者需要AngularJS相关的培训，一方面是找自己组内的专家组织一次内部培训，，另一种是找办公室内相关的专家来进行培训，形式比较灵活。
 项目中已经在使用的技术 项目中将要使用的技术 请别的组的专家来咨询  社区  OpenParty Rails Girl  问题  谁当讲师 活动经费 内容如何持久化（人，内部知识分享系统） 如何保证效果（宽松）  由于对任何的话题都没有限制，也没有对参与者的限制，因此任何人只要感兴趣都可以作为讲师。而又由于没有任何的强制措施，参与者和主讲者都凭着自己的热情来组织，这也算是比较独树一帜的事情。
而关于内容的持久化，更多的是为参与者打开一扇新的窗户，或者说洒下一些火星，而至于火星如何形成燎原之势，则完全在参与者自己的自觉。好多次和客户分享了我们的培训机制之后，被问到最多的问题是如何强迫参与者产生热情？
这个问题在ThoughtWorks不是问题，我们在一个人进入公司的最开始，也就是面试的时候，就考察了他的热情，如果在热情上有缺陷，则很可能会直接拒掉，免得破坏我们好不容易构建起来的学习氛围。</description>
      <content:encoded><![CDATA[<h3 id="thoughtworks内部培训">ThoughtWorks内部培训</h3>
<p>对新人的培训是每个企业都绕不开的一个话题，企业当然想要每个新人都能直接独当一面，最好可以直接上项目贡献自己的价值。但是从经验来看，所有新人到一个新环境都需要学习很多不同的新东西（新技术，框架，语言，工作方式等等），而每个企业对于培训新人都有各种各样的策略，比如老人带新人，比如扔到项目上让新人自己学。</p>
<p>在ThoughtWorks，我们有着丰富的培训方式，有面向社招的，有面向毕业生的，有民间自发的，有官方组织的，有内部的，也有面向社区的。</p>
<h4 id="twu">TWU</h4>
<p>TWU全称ThoughtWorks University，面向毕业生，入职之后的第一堂课。TWU的地点设在印度，之前在班加罗尔，后来改到了普内。每一期5周，学生们需要和和全球其他国家地区的同学一起，一般会尽量将各个地区的学生打乱安排，尽量让学生体会多元化的文化，培训内容设计公司文化，软件开发方法论，敏捷开发（Project SImulation）实践等，同时还需要保证学生有足够的代码练习机会。</p>
<p>我在2013年作为讲师参加了一起TWU，对我自己的帮助也非常大，在和来自不同地区的讲师一起备课，学习中学习到了很多的东西，之前似是而非的一些概念也得到了纠正。</p>
<p><img loading="lazy" src="/images/2015/02/twu33-resized.png" type="" alt="twu"  /></p>
<h4 id="twi">TWI</h4>
<p>TWI全称ThoughtWorks Immersion，面向有经验的社招同事，主要涉及的内容为公司文化（合作，沟通），专业服务（如何专业的解决客户的问题），软件开发流程，敏捷开发方法论等。</p>
<p>我在2012年时参加过TWI，并整理了几篇相关文章，可以参考<a href="http://icodeit.org/2012/08/thoughtworks-immersion-day-1/">这里</a>，<a href="http://icodeit.org/2012/08/thoughtworks-immersion-day-2/">这里</a>还有<a href="http://icodeit.org/2012/08/thoughtworks-immersion-day-3/">这里</a>。</p>
<p><img loading="lazy" src="/images/2015/01/twi-resized.png" type="" alt="twi"  /></p>
<h4 id="session">Session</h4>
<p>Office局限在ThoughtWorks办公室之内，内容随意，参加不参加随意，可以随时加入或随时离开。虽然内容没有限制，但是大多数时候分享的都是技术主题。比如<code>自动化部署</code>，<code>自动测试</code>，<code>Spring 4</code>，<code>Ruby中的构建工具</code>等等。</p>
<p>Sessoin的形式是主讲者找一个自己感兴趣的主题，一个人讲，其他参与者听，鼓励互动。时间一般控制在一个小时以内，所以一般选择在中午饭的时候，有的session会给大家订饭，一边吃一边听。</p>
<p>虽然大部分Sessoin的主题是技术相关的，但是并不局限于此。比如旅游见闻，历史，财务，摄影等等，都可以分享，有时候这些趣味性的Session的参与者更多。</p>
<p><img loading="lazy" src="/images/2015/01/session-resized.png" type="" alt="session"  /></p>
<h4 id="workshop">WorkShop</h4>
<p>Office之内，内容随意，以动手为主，讲解为辅。</p>
<ul>
<li>HTML/CSS</li>
<li>Testable JavaScript</li>
<li>设计工作坊</li>
<li>OO BootCamp</li>
<li>Ruby BootCamp</li>
</ul>
<p>一般来说，Workshop都会组成一个系列，通常会占用几天到几周不等。参与者需要带上电脑，在课堂上进行练习之外，课后还会有一些练习。</p>
<p><img loading="lazy" src="/images/2015/01/workshop-resized.png" type="" alt=""  /></p>
<p><a href="http://icodeit.org/3-pages-in-3-weeks/">3周3页面</a>和<a href="http://icodeit.org/lwweb/">可测试的JavaScript</a>是我去年做的两个Workshop。由于Workshop会在下班后或者中午的休息时间，公司会为每个参与者订饭，以节省时间。</p>
<h4 id="郑大晔校">郑大晔校</h4>
<p>面向刚刚得到offer的毕业生，在上项目之前，我们希望学生的基本技术达到特定的水平，因此设置了一系列的练习。包括</p>
<ul>
<li>编程基础</li>
<li>开发流程</li>
<li>工作方式</li>
<li>公司文化</li>
</ul>
<p>等等。郑大晔校的周期为每周一次，一次一天。涉及的内容会与大多数项目上的要求一致，比如西安office的Java/Ruby项目居多，我们的课程安排就会涉及到<code>Java/Ruby</code>方面。当然，各种软技能如工作方式也会在课程中涉及，尽量的寓教于乐。</p>
<p>每期郑大晔校大概会有10周，学生入职之后有的会直接去TWU，有的则会在项目上工作一段时间再去TWU。</p>
<p><img loading="lazy" src="/images/2015/01/zhengda-resized.png" type="" alt=""  /></p>
<h4 id="组内培训">组内培训</h4>
<p>各个组内自行组织，并不要求其他同事参加。比如某个项目需要一些<code>docker</code>的知识，或者需要<code>AngularJS</code>相关的培训，一方面是找自己组内的专家组织一次内部培训，，另一种是找办公室内相关的专家来进行培训，形式比较灵活。</p>
<ul>
<li>项目中已经在使用的技术</li>
<li>项目中将要使用的技术</li>
<li>请别的组的专家来咨询</li>
</ul>
<p><img loading="lazy" src="/images/2015/01/group-resized.png" type="" alt="group learn"  /></p>
<h4 id="社区">社区</h4>
<ul>
<li>OpenParty</li>
<li>Rails Girl</li>
</ul>
<p><img loading="lazy" src="/images/2015/02/rails-girl-session-resized.png" type="" alt="rails girl"  /></p>
<h4 id="问题">问题</h4>
<ul>
<li>谁当讲师</li>
<li>活动经费</li>
<li>内容如何持久化（人，内部知识分享系统）</li>
<li>如何保证效果（宽松）</li>
</ul>
<p>由于对任何的话题都没有限制，也没有对参与者的限制，因此任何人只要感兴趣都可以作为讲师。而又由于没有任何的强制措施，参与者和主讲者都凭着自己的热情来组织，这也算是比较独树一帜的事情。</p>
<p>而关于内容的持久化，更多的是为参与者打开一扇新的窗户，或者说洒下一些火星，而至于火星如何形成燎原之势，则完全在参与者自己的自觉。好多次和客户分享了我们的培训机制之后，被问到最多的问题是如何<code>强迫</code>参与者产生热情？</p>
<p>这个问题在ThoughtWorks不是问题，我们在一个人进入公司的最开始，也就是面试的时候，就考察了他的热情，如果在热情上有缺陷，则很可能会直接拒掉，免得破坏我们好不容易构建起来的学习氛围。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>我的2014</title>
      <link>https://icodeit.org/2014/12/my-2014/</link>
      <pubDate>Sat, 27 Dec 2014 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2014/12/my-2014/</guid>
      <description>依照惯例，我每年在元旦时候都会写一篇回顾，总结过去，展望未来。不过很少跟上一年指定的计划真正去比较，一般都是列举一下这一年做的事情。
大致分下来，可以分为上半年和下半年两部分，这当然不是废话。因为上半年和下半年分别在两个完全不同的项目上工作。
技术咨询项目 上半年在一个国内咨询项目上，主要做的事情有（其实我是作为前端专家加入的，不过后来工作重心发生了改变）：
 GIS平台 大数据平台  关于GIS最后的产出是一系列博客，而且还在InfoQ上发表了一篇。
而后来我又根据我iPhone上照片的经纬度信息，汇总出了一个热力图（使用QGis）：
大数据相关的所有东西都在我的gist上，还没有时间整理。
硬件 回到办公室之后，发现了硬件小组提供的一大堆有意思的工具和器件，包括3D打印机，Arduino的一些芯片等，为了纪念我的GIS项目，我还打印了一个瓦片：
不断将我拖延了4年的机器小车组装了起来，而且还使用舵机，蓝牙，超声波等模块制作了一个实际的雷达：
Sessions &amp;amp; Workshop 5月底回到办公室后，我发现Office的气氛其实比我来的时候低落了很多，ThoughtWorks的感觉非常淡了。
一方面是新人太多，而来新的项目所在的11楼由于客户的关系（我自以为），同事们的积极性极低。一个最容易看到的信号就是Session变得很少，我尝试做一些改变。
分别做了一些关于自动化测试，JavaScript方面的Session和Workshop，下面是《可测试的JavaScript》的Workshop。这是我第一次组织比较大的，而且时间比较长的Workshop。
有了上一次的Feedback，在年底的时候，我又组织了一次为期3周的Workshop，受众更是扩大到了各种角色，包括BA，UX，UIDev，QA等等。
写作 今年的博客数量减少了，一个原因是我在编写我的第二本书《轻量级Web应用开发》，经过几个月的坚持和努力，这本书已经编写完成，应该会在明年(2015年)年初与读者见面。
另外，在休年假的时候（3周3页面之后），我将Workshop的内容做了整理，并加入了一些设计相关的内容，形成了一本电子书，名为《3 web designs in 3 weeks》。
其他 我正在努力的向UX角色的转变，所谓千里之行，始于足下。我在休年假期间，买了一大堆UX相关的书籍。目前正在努力学习画画：
在今天的CST的创新课上，我们一起设想了几个场景，下面是我自己画的图：
最后是一张我自己设计的自己的名片：
希望来年可以在自己努力的路上看到一些成果吧。</description>
      <content:encoded><![CDATA[<p>依照惯例，我每年在元旦时候都会写一篇回顾，总结过去，展望未来。不过很少跟上一年指定的<code>计划</code>真正去比较，一般都是列举一下这一年做的事情。</p>
<p>大致分下来，可以分为上半年和下半年两部分，这当然不是废话。因为上半年和下半年分别在两个完全不同的项目上工作。</p>
<h3 id="技术咨询项目">技术咨询项目</h3>
<p>上半年在一个国内咨询项目上，主要做的事情有（其实我是作为前端专家加入的，不过后来工作重心发生了改变）：</p>
<ol>
<li>GIS平台</li>
<li>大数据平台</li>
</ol>
<p>关于GIS最后的产出是一系列博客，而且还在<a href="http://www.infoq.com/cn/articles/visualization-of-the-global-seismic-system">InfoQ</a>上发表了一篇。</p>
<p><img loading="lazy" src="/images/2014/04/openlayers-earthquake-resized.png" type="" alt="earthquake"  /></p>
<p>而后来我又根据我iPhone上照片的经纬度信息，汇总出了一个热力图（使用<a href="http://qgis.org/en/site/">QGis</a>）：</p>
<p><img loading="lazy" src="/images/2014/12/places-resized.png" type="" alt="heat map"  /></p>
<p>大数据相关的所有东西都在<a href="https://gist.github.com/abruzzi">我的gist上</a>，还没有时间整理。</p>
<h3 id="硬件">硬件</h3>
<p>回到办公室之后，发现了硬件小组提供的一大堆有意思的工具和器件，包括<code>3D打印机</code>，<code>Arduino</code>的一些芯片等，为了纪念我的GIS项目，我还打印了一个瓦片：</p>
<p><img loading="lazy" src="/images/2014/12/tile-resized.png" type="" alt="tile"  /></p>
<p>不断将我拖延了4年的机器小车组装了起来，而且还使用舵机，蓝牙，超声波等模块制作了一个实际的雷达：</p>
<p><img loading="lazy" src="/images/2014/12/radar-resized.png" type="" alt="radar"  /></p>
<h3 id="sessions--workshop">Sessions &amp; Workshop</h3>
<p>5月底回到办公室后，我发现Office的气氛其实比我来的时候低落了很多，ThoughtWorks的感觉非常淡了。</p>
<p>一方面是新人太多，而来新的项目所在的11楼由于客户的关系（我自以为），同事们的积极性极低。一个最容易看到的信号就是Session变得很少，我尝试做一些改变。</p>
<p>分别做了一些关于自动化测试，JavaScript方面的Session和Workshop，下面是《可测试的JavaScript》的Workshop。这是我第一次组织比较大的，而且时间比较长的Workshop。</p>
<p><img loading="lazy" src="/images/2014/12/testable-javascript-resized.png" type="" alt="testable-javascript"  /></p>
<p>有了上一次的Feedback，在年底的时候，我又组织了一次为期3周的Workshop，受众更是扩大到了各种角色，包括BA，UX，UIDev，QA等等。</p>
<p><img loading="lazy" src="/images/2014/12/3-pages-resized.png" type="" alt="3 pages"  /></p>
<h3 id="写作">写作</h3>
<p>今年的博客数量减少了，一个原因是我在编写我的第二本书<a href="http://icodeit.org/lwweb/">《轻量级Web应用开发》</a>，经过几个月的坚持和努力，这本书已经编写完成，应该会在明年(2015年)年初与读者见面。</p>
<p>另外，在休年假的时候（3周3页面之后），我将Workshop的内容做了整理，并加入了一些<code>设计</code>相关的内容，形成了一本电子书，名为<a href="http://juntao.gitbooks.io/3-web-designs-in-3-weeks/">《3 web designs in 3 weeks》</a>。</p>
<h3 id="其他">其他</h3>
<p>我正在努力的向<code>UX</code>角色的转变，所谓<code>千里之行，始于足下</code>。我在休年假期间，买了一大堆UX相关的书籍。目前正在努力学习画画：</p>
<p><img loading="lazy" src="/images/2014/12/drawing-resized.png" type="" alt="两点透视"  /></p>
<p>在今天的CST的创新课上，我们一起设想了几个场景，下面是我自己画的图：</p>
<p><img loading="lazy" src="/images/2014/12/scenario-resized.png" type="" alt="场景"  /></p>
<p>最后是一张我自己设计的自己的名片：</p>
<p><img loading="lazy" src="/images/2014/12/my-card-resized.png" type="" alt="name card"  /></p>
<p>希望来年可以在自己努力的路上看到一些成果吧。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>测试驱动开发实例</title>
      <link>https://icodeit.org/2014/11/tdd-step-by-step/</link>
      <pubDate>Sun, 09 Nov 2014 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2014/11/tdd-step-by-step/</guid>
      <description>示例的需求描述 今天我们需要完成的需求是这样的：
对于一个给定的字符串，如果其中元音字母数目在整个字符串中的比例超过了30%，则将该元音字母替换成字符串mommy，额外的，在替换时，如果有连续的元音出现，则仅替换一次。
如果用实例化需求(Specification by Example)的方式来描述的话，需求可以转换成这样几条实例：
 hmm经过处理之后，应该保持原状 she经过处理之后，应该被替换为shmommy hear经过处理之后，应该被替换为hmommyr  当然，也可以加入一些边界值的检测，比如包含数字，大小写混杂的场景来验证，不过我们暂时可以将这些场景抛开，而仅仅关注与TDD本身。
为什么选择这个奇怪的例子 我记得在学校的时候，最害怕看到的就是书上举的各种离生活很远的例子，比如国外的书籍经常举汽车的例子，有引擎，有面板，但是作为一个只是能看到街上跑的车的穷学生，实际无法理解其中的关联关系。
其实，另外一种令人不那么舒服的例子是那种纯粹为了示例而编写的例子，现实世界中可能永远都不可能见到这样的代码，比如我们今天用到的例子。
当然，这种纯粹的例子也有其存在的价值：在脱离开复杂的细节之后，尽量的让读者专注于某个方面，从而达到对某方面练习的目的。因为跟现实完全相关的例子往往会变得复杂，很容易让读者转而去考虑复杂性本身，而忽略了对实践/练习的思考。
TDD步骤 通常的描述中，TDD有三个步骤：
 先编写一个测试，由于此时没有任何实现，因此测试会失败 编写实现，以最快，最简单的方式，此时测试会通过 查看实现/测试，有没有改进的余地，如果有的话就用重构的方式来优化，并在重构之后保证测试通过  它的好处显而易见：
 时时关注于实现功能，这样不会跑偏 每个功能都有测试覆盖，一旦改错，就会有测试失败 重构时更有信心，不用怕破坏掉已有的功能 测试即文档，而且是不会过期的文档，因为一旦实现变化，相关测试就会失败  使用TDD，一个重要的实践是测试先行。其实在编写任何测试之前，更重要的一个步骤是任务分解(Tasking)。只有当任务分解到恰当的粒度，整个过程才可能变得比较顺畅。
回到我们的例子，我们在知道整个需求的前提下，如何进行任务分解呢？作为实现优先的程序员，很可能会考虑诸如空字符串，元音比例是否到达30%等功能。这当然没有孰是孰非的问题，不过当需求本身就很复杂的情况下，这种直接面向实现的方式可能会导致越走越偏，考虑的越来越复杂，而耗费了几个小时的设计之后发现没有任何的实际进度。
如果是采用TDD的方式，下面的方式是一种可能的任务分解：
 输入一个非元音字符，并预期返回字符本身 输入一个元音，并预期返回mommy 输入一个元音超过30%的字符串，并预期元音被替换 输入一个元音超过30%，并且存在连续元音的字符串，并预期只被替换一次  当然，这个任务分解可能并不是最好的，但是是一个比较清晰的分解。
实践 第一个任务 在本文中，我们将使用JavaScript来完成该功能的编写，测试框架采用了Jasmine，这里有一个模板项目，使用它你可以快速的启动，并跟着本教程一起实践。
根据任务分解，我们编写的第一个测试是：
describe(&amp;#34;mommify&amp;#34;, function() { it(&amp;#34;should return h when given h&amp;#34;, function() { var expected = &amp;#34;h&amp;#34;; var result = mommify(&amp;#34;h&amp;#34;); expect(result).toEqual(expected); }); }); 这个测试中有三行代码，这也是一般测试的标准写法，简称3A：
 组织数据（Arrange） 执行需要被测的函数（Action） 验证结果（Assertion）  运行这个测试，此时由于还没有实现代码，因此Jasmine会报告失败。接下来我们用最快速的方法来编写实现，就目前来看，最简单的方式就是：</description>
      <content:encoded><![CDATA[<h3 id="示例的需求描述">示例的需求描述</h3>
<p>今天我们需要完成的需求是这样的：</p>
<p>对于一个给定的字符串，如果其中<code>元音</code>字母数目在整个字符串中的比例超过了30%，则将该<code>元音</code>字母替换成字符串<code>mommy</code>，额外的，在替换时，如果有连续的元音出现，则仅替换一次。</p>
<p>如果用<code>实例化需求</code>(<a href="http://specificationbyexample.com/">Specification by Example</a>)的方式来描述的话，需求可以转换成这样几条实例：</p>
<ol>
<li><code>hmm</code>经过处理之后，应该保持原状</li>
<li><code>she</code>经过处理之后，应该被替换为<code>shmommy</code></li>
<li><code>hear</code>经过处理之后，应该被替换为<code>hmommyr</code></li>
</ol>
<p>当然，也可以加入一些边界值的检测，比如包含数字，大小写混杂的场景来验证，不过我们暂时可以将这些场景抛开，而仅仅关注与TDD本身。</p>
<h4 id="为什么选择这个奇怪的例子">为什么选择这个<code>奇怪的</code>例子</h4>
<p>我记得在学校的时候，最害怕看到的就是书上举的各种离<code>生活</code>很远的例子，比如国外的书籍经常举汽车的例子，有引擎，有面板，但是作为一个只是能看到街上跑的车的穷学生，实际无法理解其中的关联关系。</p>
<p>其实，另外一种令人不那么舒服的例子是那种纯粹为了示例而编写的例子，现实世界中可能永远都不可能见到这样的代码，比如我们今天用到的例子。</p>
<p>当然，这种纯粹的例子也有其存在的价值：在脱离开复杂的细节之后，尽量的让读者专注于某个方面，从而达到对某方面练习的目的。因为跟现实完全相关的例子往往会变得复杂，很容易让读者转而去考虑复杂性本身，而忽略了对实践/练习的思考。</p>
<h4 id="tdd步骤">TDD步骤</h4>
<p>通常的描述中，<code>TDD</code>有三个步骤：</p>
<ol>
<li>先编写一个测试，由于此时没有任何实现，因此测试会失败</li>
<li>编写实现，以最快，最简单的方式，此时测试会通过</li>
<li>查看实现/测试，有没有改进的余地，如果有的话就用重构的方式来优化，并在重构之后保证测试通过</li>
</ol>
<p><img loading="lazy" src="/images/2014/11/tdd.png" type="" alt="tdd"  /></p>
<p>它的好处显而易见：</p>
<ol>
<li>时时关注于实现功能，这样不会跑偏</li>
<li>每个功能都有测试覆盖，一旦改错，就会有测试失败</li>
<li>重构时更有信心，不用怕破坏掉已有的功能</li>
<li>测试即文档，而且是不会过期的文档，因为一旦实现变化，相关测试就会失败</li>
</ol>
<p>使用<code>TDD</code>，一个重要的实践是<code>测试先行</code>。其实在编写任何测试之前，更重要的一个步骤是<code>任务分解</code>(Tasking)。只有当任务分解到恰当的粒度，整个过程才可能变得比较顺畅。</p>
<p>回到我们的例子，我们在知道整个需求的前提下，如何进行任务分解呢？作为<code>实现优先</code>的程序员，很可能会考虑诸如空字符串，元音比例是否到达30%等功能。这当然没有孰是孰非的问题，不过当需求本身就很复杂的情况下，这种直接面向实现的方式可能会导致越走越偏，考虑的越来越复杂，而耗费了几个小时的设计之后发现没有任何的实际进度。</p>
<p>如果是采用<code>TDD</code>的方式，下面的方式是一种可能的任务分解：</p>
<ol>
<li>输入一个非元音字符，并预期返回字符本身</li>
<li>输入一个元音，并预期返回<code>mommy</code></li>
<li>输入一个元音超过30%的字符串，并预期元音被替换</li>
<li>输入一个元音超过30%，并且存在连续元音的字符串，并预期只被替换一次</li>
</ol>
<p>当然，这个任务分解可能并不是<code>最好的</code>，但是是一个比较清晰的分解。</p>
<h3 id="实践">实践</h3>
<h4 id="第一个任务">第一个任务</h4>
<p>在本文中，我们将使用JavaScript来完成该功能的编写，测试框架采用了<a href="http://jasmine.github.io/2.0/introduction.html">Jasmine</a>，这里有一个<a href="https://github.com/abruzzi/tdd-boilerplate">模板项目</a>，使用它你可以快速的启动，并跟着本教程一起实践。</p>
<p>根据任务分解，我们编写的第一个测试是：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">describe</span><span class="p">(</span><span class="s2">&#34;mommify&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
	<span class="nx">it</span><span class="p">(</span><span class="s2">&#34;should return h when given h&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
		<span class="kd">var</span> <span class="nx">expected</span> <span class="o">=</span> <span class="s2">&#34;h&#34;</span><span class="p">;</span>

		<span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">mommify</span><span class="p">(</span><span class="s2">&#34;h&#34;</span><span class="p">);</span>

		<span class="nx">expect</span><span class="p">(</span><span class="nx">result</span><span class="p">).</span><span class="nx">toEqual</span><span class="p">(</span><span class="nx">expected</span><span class="p">);</span>
	<span class="p">});</span>
<span class="p">});</span>
</code></pre></div><p>这个测试中有三行代码，这也是一般测试的标准写法，简称<code>3A</code>：</p>
<ol>
<li>组织数据（Arrange）</li>
<li>执行需要被测的函数（Action）</li>
<li>验证结果（Assertion）</li>
</ol>
<p>运行这个测试，此时由于还没有实现代码，因此Jasmine会报告失败。接下来我们用最快速的方法来编写实现，就目前来看，最简单的方式就是：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">()</span> <span class="p">{</span>
	<span class="k">return</span> <span class="s2">&#34;h&#34;</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>可能有人觉得这种实现太过狡猾，但是从<code>TDD</code>的角度来说，它确实能够令测试通过。这时候，我们需要编写另外一个测试来<code>驱动</code>出正确的行为：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">it</span><span class="p">(</span><span class="s2">&#34;should return m when given m&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
    <span class="kd">var</span> <span class="nx">expected</span> <span class="o">=</span> <span class="s2">&#34;m&#34;</span><span class="p">;</span>

    <span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">mommify</span><span class="p">(</span><span class="s2">&#34;m&#34;</span><span class="p">);</span>

    <span class="nx">expect</span><span class="p">(</span><span class="nx">result</span><span class="p">).</span><span class="nx">toEqual</span><span class="p">(</span><span class="nx">expected</span><span class="p">);</span>
<span class="p">});</span>
</code></pre></div><p>这样，我们的实现就不能仅仅返回一个&quot;h&quot;了，就现在来看，最简单的方式是输入什么就返回什么：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">word</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>很好，这样我们的第一个<code>任务</code>已经完成了！我们已经经历了<code>失败-成功</code>的循环，这时候需要<code>review</code>一下代码，以保证代码是干净的：实现上来说，并没有可以优化的地方，但是我们发现两个测试用例其实测试的是同一件事情，因此可以删掉一个。</p>
<p>是的，测试代码也是代码，我们需要小心的维护它，以保证所有的代码都是干净的。</p>
<h4 id="第二个任务">第二个任务</h4>
<p>我们可以开始元音字母的子任务了，很容易想到的一个测试用例为：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">it</span><span class="p">(</span><span class="s2">&#34;should return mommy when given a&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
    <span class="kd">var</span> <span class="nx">expected</span> <span class="o">=</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>

    <span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">mommify</span><span class="p">(</span><span class="s2">&#34;a&#34;</span><span class="p">);</span>

    <span class="nx">expect</span><span class="p">(</span><span class="nx">result</span><span class="p">).</span><span class="nx">toEqual</span><span class="p">(</span><span class="nx">expected</span><span class="p">);</span>
<span class="p">});</span>
</code></pre></div><p>测试失败之后，能想到的最快速的方式是做一个简单的判断：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">if</span><span class="p">(</span><span class="nx">word</span> <span class="o">==</span> <span class="s2">&#34;a&#34;</span><span class="p">)</span> <span class="p">{</span>
    	<span class="k">return</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
    <span class="p">}</span>
	<span class="k">return</span> <span class="nx">word</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>这样测试又会通过，接下来就是重复5个元音的场景，不过使用JavaScript可以很容易的将这5个场景归为一组：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">it</span><span class="p">(</span><span class="s2">&#34;should return mommy when given a vowel&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
    <span class="kd">var</span> <span class="nx">expected</span> <span class="o">=</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>

	<span class="p">[</span><span class="s2">&#34;a&#34;</span><span class="p">,</span> <span class="s2">&#34;e&#34;</span><span class="p">,</span> <span class="s2">&#34;i&#34;</span><span class="p">,</span> <span class="s2">&#34;o&#34;</span><span class="p">,</span> <span class="s2">&#34;u&#34;</span><span class="p">].</span><span class="nx">forEach</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	    <span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">);</span>
    	<span class="nx">expect</span><span class="p">(</span><span class="nx">result</span><span class="p">).</span><span class="nx">toEqual</span><span class="p">(</span><span class="nx">expected</span><span class="p">);</span>
    <span class="p">});</span>
<span class="p">});</span>
</code></pre></div><p>而实现则对一个的会变成（记住，用最简单的方式）：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">if</span><span class="p">(</span><span class="nx">word</span> <span class="o">==</span> <span class="s2">&#34;a&#34;</span> <span class="o">||</span> <span class="nx">word</span> <span class="o">==</span> <span class="s2">&#34;e&#34;</span> <span class="o">||</span> <span class="nx">word</span> <span class="o">==</span> <span class="s2">&#34;i&#34;</span> <span class="o">||</span> <span class="nx">word</span> <span class="o">==</span> <span class="s2">&#34;o&#34;</span> <span class="o">||</span> <span class="nx">word</span> <span class="o">==</span> <span class="s2">&#34;u&#34;</span><span class="p">)</span> <span class="p">{</span>
    	<span class="k">return</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
    <span class="p">}</span>
	<span class="k">return</span> <span class="nx">word</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>好了，测试通过了。又是进行重构的时间了，现在看看实现，简直不忍卒读，我们使用JavaScript的字符串的<code>indexOf</code>方法可以简化这段代码：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">if</span><span class="p">(</span><span class="s2">&#34;aeiou&#34;</span><span class="p">.</span><span class="nx">indedOf</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
    	<span class="k">return</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
    <span class="p">}</span>
	<span class="k">return</span> <span class="nx">word</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>好多了！我想你现在已经或多或少的体会到了<code>TDD</code>中<code>任务分解</code>的好处了：进度可以掌握，而且目标非常明确，每一步都有相应的产出。</p>
<h4 id="第三个任务">第三个任务</h4>
<p>和之前一样，我们还是从测试开始：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">it</span><span class="p">(</span><span class="s2">&#34;should mommify if the vowels greater than 30%&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
    <span class="kd">var</span> <span class="nx">expected</span> <span class="o">=</span> <span class="s2">&#34;shmommy&#34;</span><span class="p">;</span>
    <span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">mommify</span><span class="p">(</span><span class="s2">&#34;she&#34;</span><span class="p">);</span>

    <span class="nx">expect</span><span class="p">(</span><span class="nx">result</span><span class="p">).</span><span class="nx">toEqual</span><span class="p">(</span><span class="nx">expected</span><span class="p">);</span>
<span class="p">});</span>
</code></pre></div><p>现在有一点点挑战了，因为我们的实现上一直都是单一的字符串，现在有多个了，不过没有关系，我们先按照最简单的方式来实现就对了：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
	<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">word</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">if</span><span class="p">(</span><span class="s2">&#34;aeiou&#34;</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
			<span class="nx">count</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
		<span class="p">}</span>
	<span class="p">}</span>

	<span class="kd">var</span> <span class="nx">str</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>

	<span class="k">if</span><span class="p">(</span><span class="nx">count</span><span class="o">/</span><span class="nx">word</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;=</span> <span class="mf">0.30</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">word</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
			<span class="k">if</span><span class="p">(</span><span class="s2">&#34;aeiou&#34;</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
				<span class="nx">str</span> <span class="o">+=</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
			<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
				<span class="nx">str</span> <span class="o">+=</span> <span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
			<span class="p">}</span>
		<span class="p">}</span>
	<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
		<span class="nx">str</span> <span class="o">=</span> <span class="nx">word</span><span class="p">;</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="nx">str</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>无论如何，测试通过了，我们首先计算了<code>元音</code>所占的比重，如果超过30%，则替换对应的字符，否则直接返回传入的字符串。</p>
<p>从现在来看，函数<code>mommify</code>中已经有了较多的逻辑，而且有一些重复的判断出现了（<code>&quot;aeuio&quot;.indedOf</code>），是时候做一些重构了。</p>
<p>首先将相对独立的计算元音比重的部分抽取成一个函数：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">countVowels</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>

	<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">word</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">if</span><span class="p">(</span><span class="s2">&#34;aeiou&#34;</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
			<span class="nx">count</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
		<span class="p">}</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="nx">count</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>然后，将重复的<code>&quot;aeiou&quot;.indexOf</code>部分抽取为一个独立函数：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">isVowel</span><span class="p">(</span><span class="nx">character</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="s2">&#34;aeiou&#34;</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">character</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>这样本来的代码就被简化成了：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">count</span> <span class="o">=</span> <span class="nx">countVowels</span><span class="p">(</span><span class="nx">word</span><span class="p">);</span>
	<span class="kd">var</span> <span class="nx">str</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>

	<span class="k">if</span><span class="p">(</span><span class="nx">count</span><span class="o">/</span><span class="nx">word</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;=</span> <span class="mf">0.30</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">word</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
			<span class="k">if</span><span class="p">(</span><span class="nx">isVowel</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">]))</span> <span class="p">{</span>
				<span class="nx">str</span> <span class="o">+=</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
			<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
				<span class="nx">str</span> <span class="o">+=</span> <span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
			<span class="p">}</span>
		<span class="p">}</span>
	<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
		<span class="nx">str</span> <span class="o">=</span> <span class="nx">word</span><span class="p">;</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="nx">str</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>如果细细读下来，就会发现发现对于元音是否超过30%的判断比较突兀，这里确实了一个<code>业务概念</code>，就是说，此处的<code>if</code>判断并不表意，更好的写法是讲它抽取为一个函数：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">shouldBeMommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">count</span> <span class="o">=</span> <span class="nx">countVowels</span><span class="p">(</span><span class="nx">word</span><span class="p">);</span>
	<span class="k">return</span> <span class="nx">count</span><span class="o">/</span><span class="nx">word</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;=</span> <span class="mf">0.30</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>并且，替换元音的部分，我们也可以从主函数中挪出来，得到一个小函数：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js">
<span class="kd">function</span> <span class="nx">replace</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">str</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>

	<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">word</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">if</span><span class="p">(</span><span class="nx">isVowel</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">]))</span> <span class="p">{</span>
			<span class="nx">str</span> <span class="o">+=</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
		<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
			<span class="nx">str</span> <span class="o">+=</span> <span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
		<span class="p">}</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="nx">str</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>这样，主函数得到了进一步的简化：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">mommify</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">if</span><span class="p">(</span><span class="nx">shouldBeMommify</span><span class="p">(</span><span class="nx">word</span><span class="p">))</span> <span class="p">{</span>
		<span class="k">return</span> <span class="nx">replace</span><span class="p">(</span><span class="nx">word</span><span class="p">);</span>
	<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
		<span class="k">return</span> <span class="nx">word</span><span class="p">;</span>
	<span class="p">}</span>
<span class="p">}</span>
</code></pre></div><p>太好了，现在<code>mommify</code>就更加清晰了，并且每个抽取出来的函数都有了更具意义的名字，更清晰的职责。</p>
<h4 id="第四个任务">第四个任务</h4>
<p>经过了第三步，相信你已经对如何进行<code>TDD</code>有了很好的认识，而且也更有信心进行下一个任务了。同样，我们需要先编写测试用例：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">it</span><span class="p">(</span><span class="s2">&#34;should not mommify if there are vowels sequences&#34;</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
    <span class="kd">var</span> <span class="nx">expected</span> <span class="o">=</span> <span class="s2">&#34;shmommyr&#34;</span><span class="p">;</span>
    <span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">mommify</span><span class="p">(</span><span class="s2">&#34;shear&#34;</span><span class="p">);</span>

    <span class="nx">expect</span><span class="p">(</span><span class="nx">result</span><span class="p">).</span><span class="nx">toEqual</span><span class="p">(</span><span class="nx">expected</span><span class="p">);</span>
<span class="p">});</span>
</code></pre></div><p>现在的问题关键是需要判断一个字符串中的前一个是否元音，由于我们之前已经做了足够的重构，现在需要修改的函数就变成了<code>replace</code>子函数，而不是主入口<code>mommify</code>了：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">replace</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">str</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>

	<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">word</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">if</span><span class="p">(</span><span class="nx">isVowel</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">]))</span> <span class="p">{</span>
			<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="nx">isVowel</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]))</span> <span class="p">{</span>
				<span class="nx">str</span> <span class="o">+=</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
			<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
				<span class="nx">str</span> <span class="o">+=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>
			<span class="p">}</span>
		<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
			<span class="nx">str</span> <span class="o">+=</span> <span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
		<span class="p">}</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="nx">str</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>测试通过之后，我们可以大胆的进行重构，抽取新的函数<code>next</code>：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="kd">function</span> <span class="nx">next</span><span class="p">(</span><span class="nx">current</span><span class="p">,</span> <span class="nx">previous</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">next</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>

	<span class="k">if</span><span class="p">(</span><span class="nx">isVowel</span><span class="p">(</span><span class="nx">current</span><span class="p">))</span> <span class="p">{</span>
		<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="nx">isVowel</span><span class="p">(</span><span class="nx">previous</span><span class="p">))</span> <span class="p">{</span>
			<span class="nx">next</span> <span class="o">=</span> <span class="s2">&#34;mommy&#34;</span><span class="p">;</span>
		<span class="p">}</span>
	<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
		<span class="nx">next</span> <span class="o">=</span> <span class="nx">current</span><span class="p">;</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="nx">next</span><span class="p">;</span>
<span class="p">}</span>

<span class="kd">function</span> <span class="nx">replace</span><span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">str</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>

	<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">word</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
		<span class="nx">str</span> <span class="o">+=</span> <span class="nx">next</span><span class="p">(</span><span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="p">],</span> <span class="nx">word</span><span class="p">[</span><span class="nx">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]);</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="nx">str</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div><p>最后，如果你想看完整的/最新的代码，可以<a href="https://github.com/abruzzi/mommifier">在github上</a>找到。</p>
<h4 id="结束">结束（？）</h4>
<p>重构是一个永无止境的实践，你可以不断的抽取，简化，重组。比如上例中对于常量的使用，对于JavaScript中的for的使用等，都可以更进一步。但是你需要权衡，适可而止，如果不小心做的太过，则可能引起过渡设计：引入太过的概念，过于简化的接口等。</p>
<p><code>TDD</code>是一种容易付诸实践的开发方式，在小的，简单的例子上如此，在大的，复杂的场景下也是如此。它优美且高效的地方在于：不假设任何人可以一次就写出完善的应用，而是鼓励小步前进，快速反馈，快速迭代。而演化到最后，得到的往往就是孜孜以求的优美设计。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>使用Yahoo Pipe Service来聚合你关注的博客</title>
      <link>https://icodeit.org/2014/01/use-yahoo-pipe-service-to-aggregate-blogs-you-care/</link>
      <pubDate>Wed, 01 Jan 2014 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2014/01/use-yahoo-pipe-service-to-aggregate-blogs-you-care/</guid>
      <description>ThoughtWorks好声音 ThoughtWorks好声音是一个聚合网站，内容来自众ThoughtWorker的博客，我们每周会汇聚一次，从众多的博客中挑选出一些P2(软件卓越)相关的主题，然后编为一辑，再分享出去。
但是从近100个博客中找P2相关的内容，这件事本身非常繁琐，如果每周都做这个重复劳动的话，那么软件卓越从何谈起呢？作为以解放人类为己任的程序员，我们绝对不能忍受纯体力的劳动。
获取博客地址列表 之前郑晔做了一个金数据的统计，请各位同事把自己的名字和博客地址登记在一个金数据的表单上：
接下来第一步就是把网页上的所有地址取下来，这一步很容易，从金数据的页面上用jQuery找到表格的第二列，然后将其中的文字取出来：
$(&amp;#34;table tr td:nth-child(2)&amp;#34;).map(function(key, item) { return $(item).text().trim(); }); 写到这里突发奇想，能不能用phantomjs去把这个动作自动化？
page.open(url, function (status) { if (status !== &amp;#39;success&amp;#39;) { console.log(&amp;#39;Unable to access network&amp;#39;); } else { page.injectJs(&amp;#39;jquery.js&amp;#39;); var links = page.evaluate(function() { return $(&amp;#34;table tr td:nth-child(2)&amp;#34;).map(function(key, value) { return $(value).text().trim(); }); }); var results = underscore(links).filter(function(item) { return item.length &amp;gt; 0; }).map(function(item) { if(!new RegExp(&amp;#39;^(https|http)&amp;#39;).test(item)) { return &amp;#34;http://&amp;#34; + item; } return item; }); } phantom.</description>
      <content:encoded><![CDATA[<h3 id="thoughtworks好声音">ThoughtWorks好声音</h3>
<p><a href="http://voice.thoughtworkers.org/">ThoughtWorks好声音</a>是一个聚合网站，内容来自众ThoughtWorker的博客，我们每周会汇聚一次，从众多的博客中挑选出一些P2(软件卓越)相关的主题，然后编为一辑，再分享出去。</p>
<p>但是从近100个博客中找P2相关的内容，这件事本身非常繁琐，如果每周都做这个重复劳动的话，那么软件卓越从何谈起呢？作为以解放人类为己任的程序员，我们绝对不能忍受纯体力的劳动。</p>
<h4 id="获取博客地址列表">获取博客地址列表</h4>
<p>之前郑晔做了一个<a href="https://jinshuju.net/">金数据</a>的统计，请各位同事把自己的名字和博客地址登记在一个金数据的表单上：</p>
<p><img loading="lazy" src="/images/2014/01/blog-colllecting.png" type="" alt="image"  /></p>
<p>接下来第一步就是把网页上的所有地址取下来，这一步很容易，从金数据的页面上用jQuery找到表格的第二列，然后将其中的文字取出来：</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js">
<span class="nx">$</span><span class="p">(</span><span class="s2">&#34;table tr td:nth-child(2)&#34;</span><span class="p">).</span><span class="nx">map</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">item</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">$</span><span class="p">(</span><span class="nx">item</span><span class="p">).</span><span class="nx">text</span><span class="p">().</span><span class="nx">trim</span><span class="p">();</span> 
<span class="p">});</span>

</code></pre></div><p>写到这里突发奇想，能不能用phantomjs去把这个动作自动化？</p>
<div class="highlight"><pre class="chroma"><code class="language-js" data-lang="js"><span class="nx">page</span><span class="p">.</span><span class="nx">open</span><span class="p">(</span><span class="nx">url</span><span class="p">,</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">status</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">if</span> <span class="p">(</span><span class="nx">status</span> <span class="o">!==</span> <span class="s1">&#39;success&#39;</span><span class="p">)</span> <span class="p">{</span>
        <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;Unable to access network&#39;</span><span class="p">);</span>
    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
        <span class="nx">page</span><span class="p">.</span><span class="nx">injectJs</span><span class="p">(</span><span class="s1">&#39;jquery.js&#39;</span><span class="p">);</span>
        
        <span class="kd">var</span> <span class="nx">links</span> <span class="o">=</span> <span class="nx">page</span><span class="p">.</span><span class="nx">evaluate</span><span class="p">(</span><span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
            <span class="k">return</span> <span class="nx">$</span><span class="p">(</span><span class="s2">&#34;table tr td:nth-child(2)&#34;</span><span class="p">).</span><span class="nx">map</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">key</span><span class="p">,</span> <span class="nx">value</span><span class="p">)</span> <span class="p">{</span>
                <span class="k">return</span> <span class="nx">$</span><span class="p">(</span><span class="nx">value</span><span class="p">).</span><span class="nx">text</span><span class="p">().</span><span class="nx">trim</span><span class="p">();</span>
            <span class="p">});</span>
        <span class="p">});</span>

        <span class="kd">var</span> <span class="nx">results</span> <span class="o">=</span> <span class="nx">underscore</span><span class="p">(</span><span class="nx">links</span><span class="p">).</span><span class="nx">filter</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">item</span><span class="p">)</span> <span class="p">{</span>
            <span class="k">return</span> <span class="nx">item</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">;</span> 
        <span class="p">}).</span><span class="nx">map</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">item</span><span class="p">)</span> <span class="p">{</span>
            <span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="k">new</span> <span class="nb">RegExp</span><span class="p">(</span><span class="s1">&#39;^(https|http)&#39;</span><span class="p">).</span><span class="nx">test</span><span class="p">(</span><span class="nx">item</span><span class="p">))</span> <span class="p">{</span>
                <span class="k">return</span> <span class="s2">&#34;http://&#34;</span> <span class="o">+</span> <span class="nx">item</span><span class="p">;</span>
            <span class="p">}</span>
            <span class="k">return</span> <span class="nx">item</span><span class="p">;</span>
        <span class="p">});</span>
    <span class="p">}</span>
    <span class="nx">phantom</span><span class="p">.</span><span class="nx">exit</span><span class="p">();</span>
<span class="p">});</span>

</code></pre></div><p>这样，results数组中就包含了所有的博客链接了，而且有的同事比较懒，提供的URL中不包含<code>http</code>，这段代码还顺手给这样的url添加了头尾。</p>
<p>然后<strong>第二步</strong>，我<strong>想象</strong>着应该再写个脚本，在这个数组中得每个url的后边加上诸如<code>rss</code>或者<code>atom.xml</code>之类的后缀，然后去获取每个博客的rss文件，然后根据这些信息做一些事情。吃午饭的过程中我还在想象这个工具分为几个模块，用什么样的语言来做开发等等细节。</p>
<p>吃完午饭，突然想起来之前熊杰貌似发过一个yahoo pipes生成的rss，我在邮件中翻出来之后，失望的发现我自己的博客都不在里边，想想熊杰貌似还在乌干达援助非洲人民，那就自己动手重新定义一个吧。</p>
<h4 id="yahoo-pipes-服务">Yahoo pipes 服务</h4>
<p><a href="http://pipes.yahoo.com/pipes/">Yahoo pipes</a>是一个用来定制聚合的服务，只需要定义好数据源(通常是rss/atom)，然后定义一些操作，比如排序，去重，联合等等。最后这个pipe会生成一个结果集，这些特性简直就是为我们这个需求定制的：</p>
<ol>
<li>将博客地址+'/rss' / 博客地址+'/atom.xml' 添加到一个个的fetcher上</li>
<li>将这些fetcher联合起来</li>
<li>将联合的结果排序(按照发表日期/更新日期)</li>
<li>生成最后的rss</li>
</ol>
<p>yahoo pipes提供的编辑器非常简单易用：</p>
<p><img loading="lazy" src="/images/2014/01/single-pipe.png" type="" alt="image"  /></p>
<p>而且在编辑界面底下有一个预览界面：</p>
<p><img loading="lazy" src="/images/2014/01/single-preview.png" type="" alt="image"  /></p>
<p>当然，当定义好完整的pipe之后，我们的ThoughtWorks好声音的源看起来是这样的：</p>
<p><img loading="lazy" src="/images/2014/01/tvot-pipe-resized.png" type="" alt="image"  /></p>
<p>运行这个pipe之后，得到一个preview的界面：</p>
<p><img loading="lazy" src="/images/2014/01/tvot-pipe-run-resized.png" type="" alt="image"  /></p>
<p>最后，可以将这个pipe公开发布，或者将这个pipe生成的rss订阅到阅读器中，比如<a href="http://www.vienna-rss.org/">vienna</a>:</p>
<p><img loading="lazy" src="/images/2014/01/vienna-resized.png" type="" alt="image"  /></p>
<p>然后就可以一目了然的看到最近有哪些ThoughtWorker更新了自己的博客，又有那些是P2相关的，可以<code>理论上</code>减轻我们编辑很多的工作量。</p>
<h4 id="结论">结论</h4>
<p>手里是锤子的时候，看着周围的东西都像钉子。有时候，那些又酷又炫的技巧/工具可能并非必须。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>2013年结</title>
      <link>https://icodeit.org/2013/12/by-the-end-of-2013/</link>
      <pubDate>Sun, 29 Dec 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/12/by-the-end-of-2013/</guid>
      <description>总的来说，2013年收获颇丰，感谢同事们(特别鸣谢胡凯，张凯峰，以及RCA的各位同事)的帮助，我的第一本技术书籍JavaScript核心概念及实践在今年5月出版了。8月到10月，我和王磊，张久坤两位同事，和ThoughtWorks其他office的同事一起，在印度为来自世界各地的毕业生上了近两个月的课。12月从第一个项目上roll off下来，然后加入自己的第一个咨询项目。
在期间还去西电给学生讲过一次session，接受了CSDN的一次采访，本来打算赶10月份的校园招聘去学校讲点东西，后来由于出差耽搁了。但是感谢王欢给了我一个在郑大晔校上课的机会，我们每周六会对准ThoughtWorker们讲一些软件开发得session(TDD, Refactor, Pair Programming等)。
总之，2013过的充实而紧张，希望来年能更加的充实，也希望可以跟大家分享更多的有意思的session和博客。
在TWU(ThoughtWorks University) 当老师 2013年，最大的收获，应该是自己对于压力的新的认识。有一回和胡凯聊压力这个事儿，我说我自己是认可平时带着些压力去学习、工作的，胡凯的看法则是不应该是“带着些”，而是带着最大的压力。他给我举了个游泳的例子，说你在岸边是学不会的，只有被被人踢到水里，才有可能学会。
我觉得挺有道理，8月去印度参加TWU，当然有很多困难了，比如语言问题本身；和其他国家来的trainer一起交流的问题；给一群来自世界各地的学生用英文上课的问题；我周五从项目上下来，周六飞去印度普内，周日早上到达休息了半天，然后周三就要给其他国家的trainer用英文讲一个关于社会公正的演讲，而且形式限定在pecha kucha上，在这种压力下，我不止一次的后悔为什么把自己逼的这么紧？我的真实想法是把胡凯踢到水里学游泳，我自己回西安的项目继续每天做story。
但是周三过去了，我的演讲虽然也不至于震惊四座，但是不论是英文，还是主题，还是演讲技巧本身，都得到了比较正常的feedback。我存活了下来！
如果说这个小范围的，面向trainer的，带有彩排性质的演讲的压力值为100的话，那么下一周，面对着二十多个来自世界各地的毕业生，给他们讲一个关于如何给别人feedback的session，压力值至少为500+。即使是来自墨尔本、伦敦、巴西的trainer都开始表情凝重的备课，我自己的心情就更不用说了。还有人开导我说，不论你有多紧张，坐在底下的那些家伙都比你紧张100倍。
我清楚的记得，第一天结束后，我们互相击掌，还去酒吧喝了一杯来庆祝，当然，8点就赶紧撤回住处，准备第二天的session了，但是不管怎样，我又一次的存活下来了！
压力，必须压到自己要放弃，要退缩的那种程度，才能收获最多。一咬牙过去了，就海阔天空，进入一个新境界了。很多时候，自己总会给自己找很多借口，然后自己就把自己荒废了。李仲轩老人讲，练拳也一样，有人一听说有捷径，有了贼心，就不会出功夫了。
练拳 我虽然不能算是“自幼喜欢舞刀弄枪”，但是也一直对武术比较感兴趣，只是没有耐心去吃苦练而已。小时候只是跟父亲学过一点小擒拿之类，后来从家中找到一本《少林罗汉十八手》，自学未果，倒是记得一些招式的名字，如巧纫针，披身捶，僧推门，僧伏虎之类。2006年，看到了《逝去的武林》后，对内家拳产生了浓厚的兴趣，但是苦于没有老师，倒是我的兄长在石家庄，近水楼台先得月，找到一位教授他练习形意拳的老师，我跟着站了几天三体式，学了个劈拳和崩拳。
但是我自己也知道，那跟没练是一样的，练外行都骗不了。
2007年暑假，我跟李林京老师在石家庄学过一段时间的意拳。但是开学之后回到昆明，就开始三天打鱼两天撒网，后来干脆练网也撤了，借口是内家拳练习得有老师，不然十分危险，一旦受伤则后患无穷。武林盛传“练拳容易改拳难”，一旦练错，再来纠正就非常困难，不如不练。
毕业之后，就再也没有练过，但是见过高山，也知道其中的一些窍要，就是不困下功夫练，今年年初开始感觉颈椎不舒服，上班也感觉挺累的，就又开始站站桩休息脊椎。结果一周之内，隐疾全消，而且渐渐觉得精神比以前好一些了，然后就一直坚持站桩，技击桩怕练偏，就站平步桩。
截止今天为止，除了7月份去伦敦的飞机上没站以外（下了飞机赶到酒店赶紧补上），每天都在站。夏天有一次和同事分享任忠信先生的形意拳，有人怀疑是假的，我给他们试了下，虽然没有搭手即飞，发人丈外那么神奇，但是吓吓外行的效果已经有了。
明年一定要抽时间去石家庄找李老师好好学习一段时间。练拳不但在身体上可以让人强健，而且在精神上也有很多的好处。
其实传统武术，最重要的是锻炼脊椎，腰杆挺直之后，内力渐生，丹田气满之后自然中气充足，精神也会变好，再加上老是有一种别人打不过你的优势，自然容易产生自信（大不了打一架嘛，咱不怯）。蔡元培当年说过，要文明其精神，野蛮其体魄，就是这个意思。
项目 今年的12月中旬，我从RCA项目上正式Roll off，从2012年4月加入ThoughtWorks之后，就一直在这个项目上。在这个项目上主要关注在软件交付上，和所有的BAU项目一样，在RCA，能学到一个成熟的框架是怎么实实在在运行的，从开发，测试，仿真，生产环境都是通的，如果有心的话，可以接触到自动部署，负载均衡，数据库的主备配置，各级缓存等生产上才会遇到的问题，但是很多时候又会比较无聊，因为可能更多的是在做老代码的维护，bug的修复，新功能的开发可能较少。
RCA总的来说，有经验的人居多，所以交付压力来说要小一些，而且带新人方面也没有太大压力。所以时间长了，大家都会觉得有点疲。我们会定期举行CBS(Come Build Something)，或者CSS(Come Share Something)这样的活动来刺激一下。我们团队上一般有8个人，每次CBS都是有3-4个ideas，然后结对去做，虽然不会产出什么划时代/跨世纪的产品，但是每次也都会有一些产出。可惜在坚持方面做的并不好。从项目上Roll off的当天，团队送我了一本书《人与神话》(据说排在程序员谎称读过的经典书籍排行榜的榜首，不过实话实说，当时非常感动，谢谢我们team和我并肩作战近两年的同事+朋友)：
从项目上roll off之后，加入了西安本地的一个咨询项目，以前端工程师的身份加入，新项目的人对前端开发的经验相对来说都比较少，但是有很强烈的学习愿望，而且动力也很足。新项目本身做起来也比较有意思，各种前端的比较现代的技术(测试，本地构建，CI)，框架(AngularJS, Jasmine)都可以很好的进行实践。
刚开始的时候，也是压力巨大，但是咬牙挺过前三天之后，就容易多了。单元在新的一年，可以和新的团队一起将这个项目做好。
旅游 年初和老婆去了次厦门，纯粹度假的方式，无计划，无目的，在鼓浪屿上住了两天：
7月份，我和学海兄参加了欧洲的AwayDay，本来准备讲一个关于轻量级web应用开发的session，但是后来由于session太多，我的就被cancel了。
在印度正好赶上印度的AwayDay:
在普内周边的一个古堡上：</description>
      <content:encoded><![CDATA[<p>总的来说，2013年收获颇丰，感谢同事们(特别鸣谢胡凯，张凯峰，以及RCA的各位同事)的帮助，我的第一本技术书籍<a href="http://icodeit.org/jsccp/">JavaScript核心概念及实践</a>在今年5月出版了。8月到10月，我和王磊，张久坤两位同事，和ThoughtWorks其他office的同事一起，在印度为来自世界各地的毕业生上了近两个月的课。12月从第一个项目上roll off下来，然后加入自己的第一个咨询项目。</p>
<p>在期间还去西电给学生<a href="http://blog.csdn.net/gy0305/article/details/9117859">讲过一次session</a>，<a href="http://www.csdn.net/article/2013-05-29/2815458">接受了CSDN的一次采访</a>，本来打算赶10月份的校园招聘去学校讲点东西，后来由于出差耽搁了。但是感谢王欢给了我一个在郑大晔校上课的机会，我们每周六会对准ThoughtWorker们讲一些软件开发得session(TDD, Refactor, Pair Programming等)。</p>
<p>总之，2013过的充实而紧张，希望来年能更加的充实，也希望可以跟大家分享更多的有意思的session和博客。</p>
<h4 id="在twuthoughtworks-university-当老师">在TWU(ThoughtWorks University) 当老师</h4>
<p>2013年，最大的收获，应该是自己对于<strong>压力</strong>的新的认识。有一回和胡凯聊压力这个事儿，我说我自己是认可平时带着些压力去学习、工作的，胡凯的看法则是不应该是“带着些”，而是带着最大的压力。他给我举了个游泳的例子，说你在岸边是学不会的，只有被被人踢到水里，才有可能学会。</p>
<p>我觉得挺有道理，8月去印度参加TWU，当然有很多困难了，比如语言问题本身；和其他国家来的trainer一起交流的问题；给一群来自世界各地的学生用英文上课的问题；我周五从项目上下来，周六飞去印度普内，周日早上到达休息了半天，然后周三就要给其他国家的trainer用英文讲一个关于社会公正的演讲，而且形式限定在<a href="http://www.pechakucha.org/">pecha kucha</a>上，在这种压力下，我不止一次的后悔为什么把自己逼的这么紧？我的真实想法是把胡凯踢到水里学游泳，我自己回西安的项目继续每天做story。</p>
<p><img loading="lazy" src="/images/2013/12/twu-prepare-resized.png" type="" alt="image"  /></p>
<p>但是周三过去了，我的演讲虽然也不至于震惊四座，但是不论是英文，还是主题，还是演讲技巧本身，都得到了比较正常的feedback。我存活了下来！</p>
<p>如果说这个小范围的，面向trainer的，带有彩排性质的演讲的压力值为100的话，那么下一周，面对着二十多个来自世界各地的毕业生，给他们讲一个关于如何给别人feedback的session，压力值至少为500+。即使是来自墨尔本、伦敦、巴西的trainer都开始表情凝重的备课，我自己的心情就更不用说了。还有人开导我说，不论你有多紧张，坐在底下的那些家伙都比你紧张100倍。</p>
<p><img loading="lazy" src="/images/2013/12/twu-discuss-resized.png" type="" alt="image"  /></p>
<p>我清楚的记得，第一天结束后，我们互相击掌，还去酒吧喝了一杯来庆祝，当然，8点就赶紧撤回住处，准备第二天的session了，但是不管怎样，我又一次的存活下来了！</p>
<p>压力，必须压到自己要放弃，要退缩的那种程度，才能收获最多。一咬牙过去了，就海阔天空，进入一个新境界了。很多时候，自己总会给自己找很多借口，然后自己就把自己荒废了。李仲轩老人讲，练拳也一样，有人一听说有捷径，有了贼心，就不会出功夫了。</p>
<h4 id="练拳">练拳</h4>
<p>我虽然不能算是“自幼喜欢舞刀弄枪”，但是也一直对武术比较感兴趣，只是没有耐心去吃苦练而已。小时候只是跟父亲学过一点小擒拿之类，后来从家中找到一本《少林罗汉十八手》，自学未果，倒是记得一些招式的名字，如<strong>巧纫针，披身捶，僧推门，僧伏虎</strong>之类。2006年，看到了《逝去的武林》后，对内家拳产生了浓厚的兴趣，但是苦于没有老师，倒是我的兄长在石家庄，近水楼台先得月，找到一位教授他练习形意拳的老师，我跟着站了几天三体式，学了个劈拳和崩拳。</p>
<p>但是我自己也知道，那跟没练是一样的，练外行都骗不了。</p>
<p>2007年暑假，我跟<a href="http://v.youku.com/v_show/id_XMjIzNTIyMjY0.html">李林京老师</a>在石家庄学过一段时间的意拳。但是开学之后回到昆明，就开始三天打鱼两天撒网，后来干脆练网也撤了，借口是内家拳练习得有老师，不然十分危险，一旦受伤则后患无穷。武林盛传“练拳容易改拳难”，一旦练错，再来纠正就非常困难，不如不练。</p>
<p>毕业之后，就再也没有练过，但是见过高山，也知道其中的一些窍要，就是不困下功夫练，今年年初开始感觉颈椎不舒服，上班也感觉挺累的，就又开始站站桩休息脊椎。结果一周之内，隐疾全消，而且渐渐觉得精神比以前好一些了，然后就一直坚持站桩，技击桩怕练偏，就站平步桩。</p>
<p>截止今天为止，除了7月份去伦敦的飞机上没站以外（下了飞机赶到酒店赶紧补上），每天都在站。夏天有一次和同事分享任忠信先生的形意拳，有人怀疑是假的，我给他们试了下，虽然没有搭手即飞，发人丈外那么神奇，但是吓吓外行的效果已经有了。</p>
<p>明年一定要抽时间去石家庄找李老师好好学习一段时间。练拳不但在身体上可以让人强健，而且在精神上也有很多的好处。</p>
<p>其实传统武术，最重要的是锻炼脊椎，腰杆挺直之后，内力渐生，丹田气满之后自然中气充足，精神也会变好，再加上老是有一种别人打不过你的优势，自然容易产生自信（大不了打一架嘛，咱不怯）。蔡元培当年说过，要文明其精神，野蛮其体魄，就是这个意思。</p>
<h4 id="项目">项目</h4>
<p>今年的12月中旬，我从RCA项目上正式Roll off，从2012年4月加入ThoughtWorks之后，就一直在这个项目上。在这个项目上主要关注在软件交付上，和所有的BAU项目一样，在RCA，能学到一个成熟的框架是怎么实实在在运行的，从开发，测试，仿真，生产环境都是通的，如果有心的话，可以接触到自动部署，负载均衡，数据库的主备配置，各级缓存等生产上才会遇到的问题，但是很多时候又会比较无聊，因为可能更多的是在做老代码的维护，bug的修复，新功能的开发可能较少。</p>
<p><img loading="lazy" src="/images/2013/12/rca-family-resized.png" type="" alt="image"  /></p>
<p>RCA总的来说，有经验的人居多，所以交付压力来说要小一些，而且带新人方面也没有太大压力。所以时间长了，大家都会觉得有点疲。我们会定期举行CBS(Come Build Something)，或者CSS(Come Share Something)这样的活动来刺激一下。我们团队上一般有8个人，每次CBS都是有3-4个ideas，然后结对去做，虽然不会产出什么划时代/跨世纪的产品，但是每次也都会有一些产出。可惜在坚持方面做的并不好。从项目上Roll off的当天，团队送我了一本书《人与神话》(据说排在<strong>程序员谎称读过</strong>的经典书籍排行榜的榜首，不过实话实说，当时非常感动，谢谢我们team和我并肩作战近两年的同事+朋友)：</p>
<p><img loading="lazy" src="/images/2013/12/rca-memory-resized.png" type="" alt="image"  /></p>
<p>从项目上roll off之后，加入了西安本地的一个咨询项目，以前端工程师的身份加入，新项目的人对前端开发的经验相对来说都比较少，但是有很强烈的学习愿望，而且动力也很足。新项目本身做起来也比较有意思，各种前端的比较现代的技术(测试，本地构建，CI)，框架(AngularJS, Jasmine)都可以很好的进行实践。</p>
<p><img loading="lazy" src="/images/2013/12/gis-front-end-resized.png" type="" alt="image"  /></p>
<p>刚开始的时候，也是压力巨大，但是咬牙挺过前三天之后，就容易多了。单元在新的一年，可以和新的团队一起将这个项目做好。</p>
<h4 id="旅游">旅游</h4>
<p>年初和老婆去了次厦门，纯粹度假的方式，无计划，无目的，在鼓浪屿上住了两天：</p>
<p>7月份，我和学海兄参加了欧洲的AwayDay，本来准备讲一个关于轻量级web应用开发的session，但是后来由于session太多，我的就被cancel了。</p>
<p><img loading="lazy" src="/images/2013/12/london-eye-resized.png" type="" alt="image"  /></p>
<p>在印度正好赶上印度的AwayDay:</p>
<p><img loading="lazy" src="/images/2013/12/india-away-day-resized.png" type="" alt="image"  /></p>
<p>在普内周边的一个古堡上：</p>
<p><img loading="lazy" src="/images/2013/12/india-hiking-resized.png" type="" alt="image"  /></p>
]]></content:encoded>
    </item>
    
    <item>
      <title>JavaScript核心概念及实践 - 封面故事</title>
      <link>https://icodeit.org/2013/04/book-cover-story/</link>
      <pubDate>Sat, 13 Apr 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/04/book-cover-story/</guid>
      <description>JavaScript核心概念及实践 - 封面故事</description>
      <content:encoded><![CDATA[<p>##虎符</p>
<p>虎符本是春秋战国时期，用以中央政权和地方军事力量之间的一种凭证，信物。一般分剖为两半，一半留在京师（右半边，古代以右为尊），另一半留在军队驻地。对方上要有军事行动，必须向中央申请，中央同意后，会派遣专人前往，为了防止有人冒充中央，假传圣旨，需要有一种凭证。</p>
<p>当然，仅仅虎符本身并不足以调动军队，同虎符一起的，还要有诏书，及中央排除的特使。虎符作为凭证，而诏书中有详细的其他信息，比如官员的任命，军队部署之类。</p>
<p>###杜虎符</p>
<p>杜虎符为1973年在西安南郊出土的，年代大约为战国时期，但是应在秦朝统一六国之前。</p>
<p><img loading="lazy" src="/images/2013/04/jscp-conver.jpg" type="" alt="image"  /></p>
<p>铭文为：</p>
<pre><code>兵甲之符，右在君，左在杜，凡兴兵披甲，用五十人以上，必会君符，乃敢行之。燔燧之事，虽毋会符，行。
</code></pre><p>虎符本身为铜铸，铭文的制作非常特殊：先刻以阴文，然后将金丝嵌入文字，再打磨光滑，因此虽历时久远，但是仍金光熠熠。</p>
<p>###阳陵虎符</p>
<p>阳陵虎符相传在山东临城出土，由于铭文中有“皇帝”字样，时代当为秦统一六国之后。</p>
<p><img loading="lazy" src="/images/2013/04/yangling-tiger-seal.resized.jpg" type="" alt="image"  /></p>
<p>铭文为：</p>
<pre><code>甲兵之符，右在皇帝，左在阳陵
</code></pre>]]></content:encoded>
    </item>
    
    <item>
      <title>成为设计师</title>
      <link>https://icodeit.org/2013/03/turning-to-a-designer/</link>
      <pubDate>Tue, 26 Mar 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/03/turning-to-a-designer/</guid>
      <description>####Hack design的建议
首先，design无处不在，它的目的是提高产品使用者的效率和易用性的。它不是一个“运用之妙，存乎一心”的东西，它是一个实实在在可以通过学习来获得的能力（正如编程或者写作或者厨艺一样，当然，如果一个人把精力和心血放在编程上，同样可以将编程做成一个“运用之妙，存乎一心”的东西。）
什么是一个好的设计？下面是设计师Dieter Rams给出的10条原则：
 创新性 使产品有用 美学 使产品可以被理解 不那么引人注目 诚实的设计 可持久的 彻底，纯粹 尽量做小的设计 环境友好  这里有原文的链接，总而言之，设计不仅仅是一个web页面，一个海报，所有的产品都会有不同程度的设计包含在其中。
####Alex的建议
想想你觉得“好看”的页面为什么好看，是字体，配色，背景色，布局还是其他？把这些记录下来，并在自己后续的设计中尝试使用。
多看一些优秀的设计，比如web页面，如果你发现上边有一些很感兴趣的特性，或者细节，比如这个菜单看着很漂亮，后者标签功能很炫，你可以用chrome的inspect来查看别人使用了什么样的HTML，又apply了那些CSS，做出了这样的效果。
如果在这个过程中，遇到一些没有见过的标签，或者标签的属性，那么去w3school上查看一下这些标签/属性的含义，尽量使用这些Tag原始的意义（设计时的初衷）。
比如div，它是divider的缩写，本来是用来分割块的，那么就用它来做分割，比如p(paragraph)标签，用来分段，可以将文字放入其中。这些都是HTML标签的设计初衷，我们应该尽量遵循，在实现的时候，如果使用原始的标签很难实现，那么可以尝试一些比较trick的方式来绕过，但是毕竟并非正途。
最后，design和编程类似，你需要不断的练习，自己动手多尝试，在研究了别人的实现之后，自己最好做一个示例出来。
####其他人的建议
最近读到的一篇写的非常好的文章，作者也是一个有开发背景的设计师，因此有很多地方可以借鉴：
 在转向designer的同时，不要丢掉编程 按照一定的顺序来学习design（可用优先，性能优先） 设计一切见得到的东西 和其他人一起讨论设计，并聆听别人 尝试分享，尝试将自己的设计讲给别人  </description>
      <content:encoded><![CDATA[<p>####Hack design的建议</p>
<p>首先，design无处不在，它的目的是提高产品使用者的效率和易用性的。它不是一个“运用之妙，存乎一心”的东西，它是一个实实在在可以通过学习来获得的能力（正如编程或者写作或者厨艺一样，当然，如果一个人把精力和心血放在编程上，同样可以将编程做成一个“运用之妙，存乎一心”的东西。）</p>
<p>什么是一个好的设计？下面是设计师Dieter Rams给出的10条原则：</p>
<ol>
<li>创新性</li>
<li>使产品有用</li>
<li>美学</li>
<li>使产品可以被理解</li>
<li>不那么引人注目</li>
<li>诚实的设计</li>
<li>可持久的</li>
<li>彻底，纯粹</li>
<li>尽量做小的设计</li>
<li>环境友好</li>
</ol>
<p><img loading="lazy" src="/images/2013/03/design-10-commandments.resized.png" type="" alt="image"  /></p>
<p>这里有<a href="http://startupsthisishowdesignworks.com/">原文的链接</a>，总而言之，设计不仅仅是一个web页面，一个海报，所有的产品都会有不同程度的设计包含在其中。</p>
<p>####Alex的建议</p>
<p>想想你觉得“好看”的页面为什么好看，是字体，配色，背景色，布局还是其他？把这些记录下来，并在自己后续的设计中尝试使用。</p>
<p>多看一些优秀的设计，比如web页面，如果你发现上边有一些很感兴趣的特性，或者细节，比如这个菜单看着很漂亮，后者标签功能很炫，你可以用chrome的inspect来查看别人使用了什么样的HTML，又apply了那些CSS，做出了这样的效果。</p>
<p>如果在这个过程中，遇到一些没有见过的标签，或者标签的属性，那么去<a href="http://www.w3schools.com/">w3school</a>上查看一下这些标签/属性的含义，尽量使用这些Tag原始的意义（设计时的初衷）。</p>
<p>比如div，它是divider的缩写，本来是用来分割块的，那么就用它来做分割，比如p(paragraph)标签，用来分段，可以将文字放入其中。这些都是HTML标签的设计初衷，我们应该尽量遵循，在实现的时候，如果使用原始的标签很难实现，那么可以尝试一些比较trick的方式来绕过，但是毕竟并非正途。</p>
<p>最后，design和编程类似，你需要不断的练习，自己动手多尝试，在研究了别人的实现之后，自己最好做一个示例出来。</p>
<p>####其他人的建议</p>
<p>最近读到的一篇写的<a href="http://somerandomdude.com/2012/01/10/transition-from-development-to-design/">非常好的文章</a>，作者也是一个有开发背景的设计师，因此有很多地方可以借鉴：</p>
<ol>
<li>在转向designer的同时，不要丢掉编程</li>
<li>按照一定的顺序来学习design（可用优先，性能优先）</li>
<li>设计一切见得到的东西</li>
<li>和其他人一起讨论设计，并聆听别人</li>
<li>尝试分享，尝试将自己的设计讲给别人</li>
</ol>
]]></content:encoded>
    </item>
    
    <item>
      <title>关于项目上的HackDay</title>
      <link>https://icodeit.org/2013/03/guan-yu-hack-day/</link>
      <pubDate>Fri, 22 Mar 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/03/guan-yu-hack-day/</guid>
      <description>在我们的项目上，会定期的举行Hackday活动。每三个月举行一次，每次正式时间为两天，每次的hackday都有一个主题，比如对某个业务模块的数据挖掘，关于某个模块的功能/执行效率的改进。</description>
      <content:encoded><![CDATA[<h2 id="关于hackday">关于Hackday</h2>
<p>在我们的项目上，会定期的举行Hackday活动。每三个月举行一次，每次正式时间为两天，每次的hackday都有一个主题，比如对某个业务模块的数据挖掘，关于某个模块的功能/执行效率的改进。</p>
<p>Hackday中的idea多是工作中接触到的痛点，但是又有一些挑战，很难在工作的时候将其完成，或者是一些有意思的主题，平时想做又不太合适（比如一些没有经过确认创新的点子）。</p>
<h3 id="hackday-1st">Hackday 1st</h3>
<p>第一次Hackday是跟<a href="http://adams.co.tt/blog">Adam</a>一起做一个数据展现的idea，Adam是墨尔本Office里一个相当senior的咨询师，我们当时做的idea是根据系统中已有的数据信息，来做一些简单的数据分析，如：</p>
<ol>
<li>找出一个地区内的所有中介，看看哪些中介持有最多的房产资料</li>
<li>找出一个地区中，可以最快卖掉手中房产的中介</li>
</ol>
<p><img loading="lazy" src="/images/2013/03/hackday-agent-info.resized.png" type="" alt="image"  /></p>
<p>我们的应用使用sinatra作为服务器；由于数据库系统已经存在，所以ORM需要做的是将对象和已存在的数据表关联，因此功能强大且可以独立使用的ActiveRecord就成了首选；模板使用haml；UI框架风格使用了BootStrap。</p>
<p>搭建环境大概只用了1到1.5个小时，在整个开发过程中，我学习到了一个专业的敏捷开发的流程：</p>
<ol>
<li>划分大的目标，使之称为小的task</li>
<li>小步前进，做完一个功能之后，进行快速的review（首先有一个可以工作的版本）</li>
<li>如果发现有潜在的问题，进行重构，以方便下一个小的task</li>
</ol>
<p>两天之后，当一个可以工作，并且很容易扩展的应用程序真实的放在我们面前的时候，我觉得十分有意思，这当然不是因为build something本身的乐趣，而是我看到一种理论在实际的生活中可以工作（而且是以一种非常有意思的方式），这个过程让我对这种开发方式产生了很多新的认识。</p>
<h3 id="hackday-2nd">Hackday 2nd</h3>
<p>第二次的idea是一个基于google map的应用，比如某人的公司在A地，老婆的公司在B地，他们最喜欢的超市在C地，然后他们想找一个离这三个地方距离都很近的房子。</p>
<p><img loading="lazy" src="/images/2013/03/hackday-neighborhood.resized.png" type="" alt="image"  /></p>
<p>同样也使用了Sinatra+haml+javascript。由于idea本身就是西安团队想出来的，所以这次的参与者都是西安office的，这样可以省去交流的成本，做起来肯快，但是问题也很严重，就是没有人做演示，别的团队也不清楚我们在干什么。</p>
<h3 id="hackday-3rd">Hackday 3rd</h3>
<p>经历了前两次，第三次的就非常official了，有story wall，有producer，有站会，有showcase，正好这段时间我们的一个客户designer在西安office出差，所以还设计了一些海报。</p>
<p><img loading="lazy" src="/images/2013/03/hackday-rango-stories.resized.png" type="" alt="image"  /></p>
<p>有了专业的designer参与，应用程序的外观立马得到了改善，看起来非常有产品的感觉：</p>
<p><img loading="lazy" src="/images/2013/03/hackday-rango-homepage.resized.png" type="" alt="image"  /></p>
<p>这次本来计划开发离线版本，使用浏览器的localStorage，但是静态网页在iPad上无法工作。team快速的做出了调整，使用sinatra（又一次）搭建了服务器，然后将应用部署在cloud上。</p>
<p>##总结</p>
<p>虽然每次的“成果”都不大，但是整个hack的过程都非常有意思，每次都可以使用前几次活动中好的工作方式，而前几次中做的不好的则可以进行改进，技术仅仅是其中的一个方面，与团队成员的协作，对自己信心的加强，通过创新来给客户带来价值，这一系列的，不那么明显的“成果”才是更重要的。</p>
<p>另一个“成果”是，我对轻量级的框架如<a href="http://www.sinatrarb.com/">sinatra</a>，引擎<a href="http://haml.info/">haml</a>等有了非常浓厚的兴趣，用这些工具可以快速的搭建用于showcase的应用程序，而且非常容易改进，非常适合小步迭代的开发方式。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>使用Heroku开发Web应用</title>
      <link>https://icodeit.org/2013/01/developing-with-heroku/</link>
      <pubDate>Sat, 26 Jan 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/01/developing-with-heroku/</guid>
      <description>###heroku 使用heroku，开发人员可以很容易的将自己的应用程序公开给世界上的其他用户使用，heroku会为你提供一个url，一些预设的空间如数据库（postgresql）等。这对于需要频繁远程showcase的场景提供了非常好的方式，当然对于开发人员向其他的开发人员或者最终用户展现自己的框架的外观/行为等场景也会非常有用。
###在heroku上注册用户 首先，当然是在heroku上注册一个开发账户，如果你已经注册过，就请接着第二步
###下载heroku的本地Toolbox heroku提供了一个很好用的工具包，通过这个工具包，开发人员可以很容易的对部署在heroku上的应用程序做操作。
###在本地登陆heroku 如果没有上传过key的话，heroku会提醒你创建一个新的ssh公钥，然后上传到heroku（这个过程与使用github非常类似）
$ heroku login Enter your Heroku credentials. Email: adam@example.com Password: Could not find an existing public key. Would you like to generate one? [Yn] Generating new SSH public key. Uploading ssh public key /Users/adam/.ssh/id_rsa.pub 如果已经上传过key，则可以直接登陆
###准备工作 在本地生成一个应用程序的基本结构，如：Gemfile，目录结构等。然后在本地配置好git环境，比如：
$ git init $ git add . $ git commit -m &amp;quot;init&amp;quot; 准备Procfile：
web: bundle exec ruby app.rb -p $PORT -E production app.rb相当于你的应用程序的主入口(main)，-E指定运行环境（此处指定为production），你的应用程序可能会根据次设置来进行一些资源的选择（数据库指向，资源文件位置等）
在上传之前，需要确保自己的应用程序可以在本地正常运行：
foreman start 应用程序将在本地的5000端口上运行，此时可以做一些简单的验证，保证应用程序运行正常。</description>
      <content:encoded><![CDATA[<p>###heroku
使用heroku，开发人员可以很容易的将自己的应用程序公开给世界上的其他用户使用，heroku会为你提供一个url，一些预设的空间如数据库（postgresql）等。这对于需要频繁远程showcase的场景提供了非常好的方式，当然对于开发人员向其他的开发人员或者最终用户展现自己的框架的外观/行为等场景也会非常有用。</p>
<p>###在heroku上注册用户
首先，当然是在heroku上<a href="https://api.heroku.com/signup/devcenter">注册一个开发账户</a>，如果你已经注册过，就请接着第二步</p>
<p>###下载heroku的本地Toolbox
heroku提供了一个很好用的<a href="https://toolbelt.heroku.com/">工具包</a>，通过这个工具包，开发人员可以很容易的对部署在heroku上的应用程序做操作。</p>
<p>###在本地登陆heroku
如果没有上传过key的话，heroku会提醒你创建一个新的ssh公钥，然后上传到heroku（这个过程与使用github非常类似）</p>
<pre><code>$ heroku login
Enter your Heroku credentials.
Email: adam@example.com
Password: 
Could not find an existing public key.
Would you like to generate one? [Yn] 
Generating new SSH public key.
Uploading ssh public key /Users/adam/.ssh/id_rsa.pub
</code></pre><p>如果已经上传过key，则可以直接登陆</p>
<p>###准备工作
在本地生成一个应用程序的基本结构，如：<code>Gemfile</code>，目录结构等。然后在本地配置好git环境，比如：</p>
<pre><code>$ git init
$ git add .
$ git commit -m &quot;init&quot;
</code></pre><p>准备Procfile：</p>
<pre><code>web: bundle exec ruby app.rb -p $PORT -E production
</code></pre><p><code>app.rb</code>相当于你的应用程序的主入口(main)，<code>-E</code>指定运行环境（此处指定为production），你的应用程序可能会根据次设置来进行一些资源的选择（数据库指向，资源文件位置等）</p>
<p>在上传之前，需要确保自己的应用程序可以在本地正常运行：</p>
<pre><code>foreman start
</code></pre><p>应用程序将在本地的5000端口上运行，此时可以做一些简单的验证，保证应用程序运行正常。</p>
<pre><code>$ git add .
$ git commit -m &quot;ready for deploy app to heroku&quot;
</code></pre><p>###上传你的App
这时，可以很轻易的将App上传到heroku了：</p>
<pre><code>$ heroku create
$ git push heroku master
</code></pre><p>当然，第一次上传可能会比较慢（取决于你应用程序的大小），如果一切正常，heroku将会尝试根据你的Gemfile来安装依赖，安装完成之后，会尝试根据Procfile中的配置启动你的应用程序。</p>
<p>如果你的应用程序会访问数据库（非postgresql的数据库），那么建议在Gemfile中指定当测试时使用该数据库，而在production环境中使用postgresql，因为heroku使用的正是postgresql：</p>
<pre><code>configure :test do
    DataMapper.setup(:default, ENV['DATABASE_URL'] || &quot;local-db-url&quot;)
    DataMapper.finalize.auto_upgrade!
end
</code></pre><p>我的应用在本地使用sqlite，而在heroku中使用其提供的postgresql。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>我需要慢一些</title>
      <link>https://icodeit.org/2013/01/where-am-i/</link>
      <pubDate>Wed, 09 Jan 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/01/where-am-i/</guid>
      <description>慢一些的生活 某个晚上，我在网上为自己挑选一个适合出差的行李箱，两个小时之后，我突然发现我停留在了一个瑞士军刀的淘宝店里；本来计划晚上看看AppleScript的资料，结果一个小时之后，我在用python写一个opencv的小程序，又过了一个小时，我停留在Alfred的PowerPack的支付页面，面对着15英镑的价格陷入沉思。
而且周围好像每个人都有这样类似的经历。我咨询其他同事遇到类似的情况怎么处理，有人推荐使用Todo列表，而且Todo最好列在纸上。当列表中的Todo被消灭时，会激发你去写下更多的task。这当然是个好办法，我很早的时候就写过一个软件来完成Todo管理：sTodo。但是当打开电脑之后，时间就完全不受控制了，网络上总是有各种各样好玩的东西，新的框架，新的语言，某种颠覆式的CSS框架，新奇而好用的软件，可以大大提高用户体验的UI库，太多了……。
上周三的晚上，回家之后打开电脑，开始了“学习”，事实上是很盲目的在网络上游荡，当我意识到又要重蹈覆辙的时候，我毅然的合起了电脑，然后拿起一本纸质的《JavaScript: The good parts》。最后当我要睡觉时才发现，读了大概30多页，而且以前的一些概念也更加清楚了。而且事实上我并未因为没有打开计算机而有什么实质性的损失。
然后我突然意识到我之前的所谓的学习的方式有很大的问题，网络当然可以为你提供大量的信息，但是很多时候，这些呈碎片装的信息的作用并不如预期般的大。它会帮你解决手头的小问题，但是阻挡了你的视线，你本可以走的更远！
在网络上看资料，总是有一种紧迫感：这么多的东西都不会，落后于时代好多年。打开电脑，一个晚上过去了，你可能读了很多的东西，但是记下来的非常少，因为总是会被各种链接，图片等干扰，这个看似在学习的过程事实上完全是在浪费实践，一天之后，你前一个晚上看到的东西几乎被完全遗忘，然后周而复始。
所以，是时候慢下来，你不会因为没有浏览几个网页，或者少读几篇文章而落后于时代几十年的，你需要好多年才能积累起来的知识，别人同样需要好多年。
合上电脑，捧起纸质的书籍，世界突然慢了下来，但是却会充盈很多。事实上，放慢脚步，消除网络带来的虚假的紧迫感，反而可以以更快的速度掌握一项技术，一个框架，也可以让印象更加深刻。晚上回家尽量不带电脑，我用training经费购买的10本书，现在才读完2.5本，去年5月买的书还有两本没有读完，这些亏欠都需要在脱离电脑的舒服之后才能想起来，也才有可能完成。
慢下来。</description>
      <content:encoded><![CDATA[<h3 id="慢一些的生活">慢一些的生活</h3>
<p>某个晚上，我在网上为自己挑选一个适合出差的行李箱，两个小时之后，我突然发现我停留在了一个瑞士军刀的淘宝店里；本来计划晚上看看AppleScript的资料，结果一个小时之后，我在用python写一个opencv的小程序，又过了一个小时，我停留在Alfred的PowerPack的支付页面，面对着15英镑的价格陷入沉思。</p>
<p>而且周围好像每个人都有这样类似的经历。我咨询其他同事遇到类似的情况怎么处理，有人推荐使用Todo列表，而且Todo最好列在纸上。当列表中的Todo被消灭时，会激发你去写下更多的task。这当然是个好办法，我很早的时候就写过一个软件来完成Todo管理：<a href="http://code.google.com/p/stodo/">sTodo</a>。但是当打开电脑之后，时间就完全不受控制了，网络上总是有各种各样好玩的东西，新的框架，新的语言，某种颠覆式的CSS框架，新奇而好用的软件，可以大大提高用户体验的UI库，太多了……。</p>
<p><img loading="lazy" src="/images/2013/01/stodo_edit.png" type="" alt="sTodo"  /></p>
<p>上周三的晚上，回家之后打开电脑，开始了“学习”，事实上是很盲目的在网络上游荡，当我意识到又要重蹈覆辙的时候，我毅然的合起了电脑，然后拿起一本纸质的《JavaScript: The good parts》。最后当我要睡觉时才发现，读了大概30多页，而且以前的一些概念也更加清楚了。而且事实上我并未因为没有打开计算机而有什么实质性的损失。</p>
<p>然后我突然意识到我之前的所谓的学习的方式有很大的问题，网络当然可以为你提供大量的信息，但是很多时候，这些呈碎片装的信息的作用并不如预期般的大。它会帮你解决手头的小问题，但是阻挡了你的视线，你本可以走的更远！</p>
<p>在网络上看资料，总是有一种紧迫感：这么多的东西都不会，落后于时代好多年。打开电脑，一个晚上过去了，你可能读了很多的东西，但是记下来的非常少，因为总是会被各种链接，图片等干扰，这个看似在学习的过程事实上完全是在浪费实践，一天之后，你前一个晚上看到的东西几乎被完全遗忘，然后周而复始。</p>
<p>所以，是时候慢下来，你不会因为没有浏览几个网页，或者少读几篇文章而落后于时代几十年的，你需要好多年才能积累起来的知识，别人同样需要好多年。</p>
<p><img loading="lazy" src="/images/2013/01/todos.png" type="" alt="image"  /></p>
<p>合上电脑，捧起纸质的书籍，世界突然慢了下来，但是却会充盈很多。事实上，放慢脚步，消除网络带来的<em><strong>虚假的紧迫感</strong></em>，反而可以以更快的速度掌握一项技术，一个框架，也可以让印象更加深刻。晚上回家尽量不带电脑，我用training经费购买的10本书，现在才读完2.5本，去年5月买的书还有两本没有读完，这些亏欠都需要在脱离电脑的舒服之后才能想起来，也才有可能完成。</p>
<p>慢下来。</p>
]]></content:encoded>
    </item>
    
    <item>
      <title>基于OpenCV的数字识别</title>
      <link>https://icodeit.org/2013/01/basic-digits-recognization/</link>
      <pubDate>Sat, 05 Jan 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/01/basic-digits-recognization/</guid>
      <description>基于OpenCV的数字识别的一个例子</description>
      <content:encoded><![CDATA[<h2 id="heading"></h2>
<p>最终的效果图是这样的：</p>
<p><img loading="lazy" src="/images/2013/01/result.resized.png" type="" alt="识别效果"  /></p>
<p>图中的一个小的窗口中为resize之后的所有找到的图片的列表，在这个case中，有三个数字。</p>
<p>数字识别即将图片中的数字通过计算机算法识别为文本。如果要从头写一个识别器，可能需要很多的实践，花费很大的精力，而且还需要有良好的数学功底才能完成，不过使用opencv提供的丰富的API和算法实现，可以比较容易的做到，而且也可以得到比较高的精确率。</p>
<p>数字识别是模式识别中的一个特例，我这里要讨论的是一个比较简单的实现，基于最简单也最容易理解的KNN算法(请参看<a href="http://icodeit.org/blog/2013/01/k-nearest-neighbour/">之前的一篇文章</a>)。</p>
<p>数字识别和其他的所有计算机视觉相关的应用都会分为两个步骤：ROI抽取和识别。</p>
<pre><code>1. ROI抽取即将感兴趣的区域从原始图像中分离初来，这个步骤包括二值化，噪点的消除等
2. 识别即通过一些分类器将第一步中的结果进行分类，事实上属于机器学习的一个典型应用
</code></pre>
<p>###图像预处理</p>
<p>原始图片中会有大量与目标无关的信息，比如人脸检测中，背景中往往有诸如桌椅，墙壁上的画，或者在户外的树木，动物等等，这些与目标无关的信息被称为噪音或者噪点，应该在进行分类之前通过一些特定的步骤来消除，不但可以减少计算量，而且还可以提高准确率。</p>
<p><img loading="lazy" src="/images/2013/01/865.origin.png" type="" alt="原始图片"  /></p>
<p>####灰度图
通常的彩色图形由3个(RGB)或者4个(RGBA)通道组成，在计算机看来，一个彩色的图片是由3/4个矩阵组成，每个矩阵中包含若干个点(比如1024x768)，如果每个通道都参与运算的话，会引入太多的计算量，因此通常的做法是将彩色图像转换为灰度图，在opencv中，这一步非常容易：</p>
<pre><code>def grayify(image):
    return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

</code></pre><p>####二值图
灰度图较之原始图片，将三个维度的矩阵变成了一个维度，已经做了部分简化，但是算法来说，噪音并未消除，灰度图中，每个点仍然有8位来表示，每个点可能的灰度为0-255，二值图即将灰度图转换成黑白图，每个点只有两种可能：非黑即白，这样将大大简化计算。</p>
<p>opencv提供了阈值调节的API，可以将灰度图转换为二值图：高于某一个阈值的点被认为是白色，反之为黑色：</p>
<pre><code>def thresholding_inv(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    ret, bin = cv2.threshold(gray, 48, 255, cv.CV_THRESH_BINARY_INV)
    bin = cv2.medianBlur(bin, 3)

    return bin
</code></pre><p>上面的代码中，48即为阈值，如果灰度高于48，那么改点会被认为是255，否则为0。效果如下：
<img loading="lazy" src="/images/2013/01/865.thres.png" type="" alt="二值图"  /></p>
<p>由于轮廓检测算法需要从黑色的背景中搜索白色的轮廓，所有此处的<code>threshold</code>最后一项参数为<code>cv.CV_THRESH_BINARY_INV</code>，即反转黑白色。</p>
<p>####轮廓检测
轮廓检测会将二值图中的可以连通的区域(一个多边形)用一系列的点描述，默认的轮廓检查会返回一个点的序列，比如用四个点描述一个矩形，但是可以通过设置精度来返回更多的点，这里我们只需要返回矩形即可：</p>
<p><img loading="lazy" src="/images/2013/01/865.contours.png" type="" alt="轮廓检查"  /></p>
<p>比较有意思的是这里的数字8，由于8这个形状中有两个圆圈，默认的轮廓检查会将这两个圆圈都检测到，那么8就会有三个轮廓，同样还可能出现这种情况的还有数字4,6,9。</p>
<pre><code>contours, heirs = cv2.findContours(thres.copy(), \
cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
</code></pre><p>因此需要指定<code>findContours</code>函数仅搜索最外层的轮廓，而不关注内部可能出现的任何轮廓：</p>
<pre><code>contours, heirs = cv2.findContours(thres.copy(), \
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
</code></pre><p>###KNN分类算法
KNN算法的原理可以参看之前的<a href="http://icodeit.org/blog/2013/01/k-nearest-neighbour/">一篇文章</a>。这里的实现主要参考了opencv的示例程序:</p>
<pre><code>class KNearest(StatModel):
    def __init__(self, k = 3):
        self.k = k
        self.model = cv2.KNearest()

    def train(self, samples, responses):
        self.model = cv2.KNearest()
        self.model.train(samples, responses)

    def predict(self, samples):
        retval, results, neigh_resp, dists = \
        self.model.find_nearest(samples, self.k)
        return results.ravel()
</code></pre><p>####数字的顺序
另外一个有意思的事情是轮廓检测的时候，算法并不一定按照从左到右，从上到下的方向进行，我开始只是简单的按照迭代的顺序将结果插入到一个list中，但是这样list中的结果是乱的，下午得到了team中有图像处理背景的<a href="http://muggleyoung.info/">杨眉同学</a>的支持：搜索到轮廓的时候，将此时的position信息与轮廓一起记录下来，然后在搜索完成之后，将整个列表按照x坐标排序(卡上的数字是按照从左向右书写)：</p>
<pre><code>class PosImage(object):
    def __init__(self, pos, image):
        self.pos = pos
        self.image = image

    def get_position(self):
        return self.pos

    def get_image(self):
        return self.image

</code></pre><p>然后在迭代中记录position信息：</p>
<pre><code>    cropped = gray[y:y+h, x:x+w]
    resized = cv2.resize(cropped, (20, 20))
    cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 3)
    pos_image = PosImage((x, y), resized)
    images.append(pos_image)
</code></pre><p>最后做一次新的arrange：</p>
<pre><code>def rearrange(images):
    return sorted(images, cmp=lambda x, y:
    cmp(x.get_position()[0], y.get_position()[0]))

</code></pre>]]></content:encoded>
    </item>
    
    <item>
      <title>K-Nearest-Neighbour 算法简介</title>
      <link>https://icodeit.org/2013/01/k-nearest-neighbour/</link>
      <pubDate>Thu, 03 Jan 2013 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2013/01/k-nearest-neighbour/</guid>
      <description>###background
元旦放假前，team的同事们想要一起学习一些技术，然后一起做些小东西，有人提到将物理墙上的卡，通过手机拍照，识别出其中的卡号，然后与电子墙同步状态。这是一个非常有意思的主题，会涉及到很多方面的知识，其实有好几个topic，只不过我对人工智能/机器学习等比较有兴趣而已，所以就先自己研究下。
几天下来，关于数字识别的基本的流程已经清晰了，关于图片的预处理及边界标定等都差不多就绪了，剩下比较重要的是识别本身了。在这个过程中，遇到了一些很有意思的算法，我自己也花费了好几天才弄明白，所以整理了一下，这一篇先介绍下第一个，也是最简单最好用的KNN算法。
###K-nearest-neighbour简介
KNN是机器学习中最简单的一种无值守的学习方法，但是在实际场景中，效果却经常非常好。一般来说，在样本较多，分布均匀的空间中，KNN会收到很好的效果。但是由于KNN会计算空间中的每个点与需要标定的点的距离(甚至需要计算额外的权重信息)，所以计算量会较大。
假设所有的点都均匀的分布在一个平面内，此时的平面密度(单位范围内的点的个数)非常大，而每个子平面内的点的分布与所有点在整个平面内的分布相当。在子平面S中，有一个点Y，则离点X(to be classified)最近的Y很可能与Y同在子平面S中。 比如取出空间中与X距离最近的有5个点(K=5)，其中3个属于C1类，2个属于C2类，则根据少数服从多数原则，X点被归类为C1.这样的一个缺点就是如果空间内的点分布不均匀，那么会有一些误差，如果上面这个场景经常出现，那么分类会越来越偏离(有一个偏心的硬币，投掷100,000次，有90,000次正面)。这样就有引入了对KNN的另一个扩展方式，加入权重的KNN：
当然这种形式的KNN不是很精确，由此引申出了带权重的KNN：可以为每个点都赋予一个权值，每个权值与新的点X的距离有关，通常会取距离的倒数，这样与X最近的点有较高的权重，而较远的点具有较低的权重，这样在投票(voting)阶段可以相对的提高精确度 ###KNN的一个python版本示例
####背景(高斯分布)
import random def gauss_list(mu, sigma, count=100): return [random.gauss(mu, sigma) for _ in range(count)] 生成一个随机数数组，数组中的元素符合高斯分布，如
ran = gauss_list(-2, 1, 10) print ran 运行结果如下：
[-1.3277188634970218, -2.1034487392146817, -0.5924407591392826, -0.30376289085064045, -2.191337071105794, -1.9781081550478732, -3.7937155472105673, -2.538102349796847, -1.3728510997834549, -2.766669661625006] 更进一步，我们可以用这种方式生成平面中的一些点，这些点可以根据分布情况分为两组，一组是以(-4,0)为重心的500个点，另一组是以(4,0)为重心的500个点：
def gauss_cluster(center, stdDev, count=500): return [(random.gauss(center[0], stdDev), random.gauss(center[1], stdDev)) for _ in range(count)] def make_random_data(): return gauss_cluster((-4, 0), 1) + gauss_cluster((4, 0), 1) data = make_random_data() ####绘制高斯分布</description>
      <content:encoded><![CDATA[<p>###background</p>
<p>元旦放假前，team的同事们想要一起学习一些技术，然后一起做些小东西，有人提到将物理墙上的卡，通过手机拍照，识别出其中的卡号，然后与电子墙同步状态。这是一个非常有意思的主题，会涉及到很多方面的知识，其实有好几个topic，只不过我对人工智能/机器学习等比较有兴趣而已，所以就先自己研究下。</p>
<p>几天下来，关于数字识别的基本的流程已经清晰了，关于图片的预处理及边界标定等都差不多就绪了，剩下比较重要的是<strong>识别</strong>本身了。在这个过程中，遇到了一些很有意思的算法，我自己也花费了好几天才弄明白，所以整理了一下，这一篇先介绍下第一个，也是最简单最好用的KNN算法。</p>
<p>###K-nearest-neighbour简介</p>
<p>KNN是机器学习中<strong>最简单</strong>的一种无值守的学习方法，但是在实际场景中，效果却经常<strong>非常好</strong>。一般来说，在样本较多，分布均匀的空间中，KNN会收到很好的效果。但是由于KNN会计算空间中的每个点与需要标定的点的距离(甚至需要计算额外的权重信息)，所以计算量会较大。</p>
<pre><code>假设所有的点都均匀的分布在一个平面内，此时的平面密度(单位范围内的点的个数)非常大，而每个子平面内的点的分布与所有点在整个平面内的分布相当。在子平面S中，有一个点Y，则离点X(to be classified)最近的Y很可能与Y同在子平面S中。
</code></pre><p>比如取出空间中与X距离最近的有5个点(K=5)，其中3个属于C1类，2个属于C2类，则根据少数服从多数原则，X点被归类为C1.这样的一个缺点就是如果空间内的点分布不均匀，那么会有一些误差，如果上面这个场景经常出现，那么分类会越来越偏离(有一个偏心的硬币，投掷100,000次，有90,000次正面)。这样就有引入了对KNN的另一个扩展方式，加入权重的KNN：</p>
<pre><code>当然这种形式的KNN不是很精确，由此引申出了带权重的KNN：可以为每个点都赋予一个权值，每个权值与新的点X的距离有关，通常会取距离的倒数，这样与X最近的点有较高的权重，而较远的点具有较低的权重，这样在投票(voting)阶段可以相对的提高精确度
</code></pre><p>###KNN的一个python版本示例</p>
<p>####背景(高斯分布)</p>
<pre><code>import random

def gauss_list(mu, sigma, count=100):
    return [random.gauss(mu, sigma) for _ in range(count)]
</code></pre><p>生成一个随机数数组，数组中的元素符合高斯分布，如</p>
<pre><code>ran = gauss_list(-2, 1, 10)
print ran
</code></pre><p>运行结果如下：</p>
<pre><code>[-1.3277188634970218, -2.1034487392146817, -0.5924407591392826, -0.30376289085064045, -2.191337071105794, -1.9781081550478732, -3.7937155472105673, -2.538102349796847, -1.3728510997834549, -2.766669661625006]
</code></pre><p>更进一步，我们可以用这种方式生成平面中的一些点，这些点可以根据分布情况分为两组，一组是以(-4,0)为重心的500个点，另一组是以(4,0)为重心的500个点：</p>
<pre><code>def gauss_cluster(center, stdDev, count=500):
    return [(random.gauss(center[0], stdDev),
             random.gauss(center[1], stdDev)) for _ in range(count)]

def make_random_data():
    return gauss_cluster((-4, 0), 1) + gauss_cluster((4, 0), 1)

data = make_random_data()

</code></pre><p>####绘制高斯分布</p>
<pre><code>data = make_random_data()

x = map(lambda x: x[0], data)
y = map(lambda x: x[1], data)

plt.clf()

plt.scatter(x, y, c=x, vmin=0, vmax=20, s=35, alpha=0.75)
plt.colorbar()
plt.grid(True)

plt.show()
</code></pre><p>通过使用matplotlib的绘图功能，将make_random_data生成的点通过图形的方式展现，效果更加直观，图中的两个点集分别表示两个不同的类别。</p>
<p><img loading="lazy" src="/images/2013/01/gauss-distribution-resized.png" type="" alt="image"  /></p>
<p>####KNN</p>
<p>我们定义KNN分类器，其中两点间的距离按照欧氏公式来求，先计算点集中离x点最近的k个点，然后取得对应的k个label，再按照label个数球max。</p>
<p>比如k=5时，求的的label集合为[&lsquo;O&rsquo;, &lsquo;O&rsquo;, &lsquo;A&rsquo;, &lsquo;A&rsquo;, &lsquo;A&rsquo;]，则我们认为这个点应该被分类为A(少数服从多数)。</p>
<pre><code>def euclidean_distance(x, y):
    return math.sqrt(sum([(a-b)**2 for (a,b) in zip(x,y)]))

def makeKNNClassifier(data, labels, k, distance):
    def classify(x):
        closestPoints = heapq.nsmallest(k, enumerate(data),
                                        key=lambda y: distance(x, y[1]))
        closestLabels = [labels[i] for (i, pt) in closestPoints]
        return max(set(closestLabels), key=closestLabels.count)

    return classify
</code></pre><p>####测试一下
创建1000个随机点，前500个分类为A(Apple)，后500个分类为O(Orange)，k值为3。</p>
<pre><code>data = make_random_data()
labels = ['A'] * 500 + ['O'] * 500

fitter = makeKNNClassifier(data, labels, 3, euclidean_distance)

print fitter((-3, 1))
print fitter((4, 2))
</code></pre><p>图中的两个红色的点分别为P1(-3, 1)和P2(4, 2)。它们都已经被正确的分类。</p>
<p><img loading="lazy" src="/images/2013/01/knn-plant-resized.png" type="" alt="image"  /></p>
]]></content:encoded>
    </item>
    
  </channel>
</rss>
