<?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>work on I Code It</title>
    <link>https://icodeit.org/categories/work/</link>
    <description>Recent content in work on I Code It</description>
    <generator>Hugo -- gohugo.io</generator>
    <lastBuildDate>Thu, 29 Aug 2019 00:00:00 +0000</lastBuildDate><atom:link href="https://icodeit.org/categories/work/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>那些年，我见过的那些&#34;废柴&#34;</title>
      <link>https://icodeit.org/2019/08/unlearn-what-you-learnt/</link>
      <pubDate>Thu, 29 Aug 2019 00:00:00 +0000</pubDate>
      
      <guid>https://icodeit.org/2019/08/unlearn-what-you-learnt/</guid>
      <description>在我们的日常工作中，和其他人一起合作在所难免。与三观未知的*他人*朝夕相处往往不啻于一场冒险。那些传说中行云流水般流畅的合作似乎仅存在于书本中，现实世界中的合作则常常难以契合，大多互相掣肘，不得通畅。毫无疑问，在众多的项目中，与我合作过的很多同事都令我大开眼界并深受启发，并在或长或短的合作中受益良多。作为对比，同样有很多同事（我把一起工作的人们都成为同事，而并不特别区分内部外部，比如团队上的其他合作方也可以视为同事）则从相反的方向令我印象深刻。</description>
      <content:encoded><![CDATA[<h2 id="那些年我见过的那些废柴">那些年，我见过的那些“废柴”</h2>
<h3 id="序">序</h3>
<p>在我们的日常工作中，和其他人一起合作在所难免。与三观未知的<em>他人</em>朝夕相处往往不啻于一场冒险。那些传说中行云流水般流畅的合作似乎仅存在于书本中，现实世界中的合作则常常难以契合，大多互相掣肘，不得通畅。毫无疑问，在众多的项目中，与我合作过的很多同事都令我大开眼界并深受启发，并在或长或短的合作中受益良多。作为对比，同样有很多同事（我把一起工作的人们都成为同事，而并不特别区分内部外部，比如团队上的其他合作方也可以视为同事）则从相反的方向令我印象深刻。</p>
<p>我仔细回想，如果整理出一个“我最不希望与之合作的人之特质”的清单的话，一来或许可以警示自己不要成为这样的人，二来潜在地也可以让具备这些特质的人从中受益。古语有云：<em>有则改之，无则加勉</em>，此之谓也。</p>
<ul>
<li>无法根据事情的重要/紧急程度划分优先级而导致自己疲于奔命的</li>
<li>只知道抱怨而不着手解决问题</li>
<li>能说不能做的</li>
<li>固步自封，不思进取</li>
<li>急于撇清责任，将自己置身事外</li>
<li>缺乏责任感，将问题归类到自己无法的力量的</li>
</ul>
<h3 id="不会化分优先级">不会化分优先级</h3>
<p>在一个团队中，效率最低的当然是那些什么都不干的人。不过可能与大部分人的直觉相反的是，<strong>什么都做</strong>的那个人效率是倒数第二低的（如果不是最低的话）。这样的人被巨大的<code>backlog</code>支配，深陷其中而无法自拔，各个未完成的任务可能还会互相影响，直至崩溃。很多时候，这些人手头的工作甚至都不是被分配的，而是他们自己揽上身的。</p>
<p>如果你认为所有任务都很重要，也就意味着所有任务都<em><strong>不</strong></em>重要。具体来说，这样的做法有很多潜在的问题，对于个人和团队都有很大坏处：</p>
<ul>
<li>个人成为信息孤岛</li>
<li>由于太多并行任务，无法真正完成某一项任务</li>
<li>WIP（<em>work in progress</em>）队列变的无限大</li>
<li>成为团队的瓶颈</li>
</ul>
<p>正如《凤凰项目》中描述的场景，那个<code>Superstar</code>成员成为了团队中最大的瓶颈。当那个<code>Superstar</code>的带宽被完全只用之后，所有的在队列中的工作都需要进入等待状态，而这个曲线是呈指数态势增长的。</p>
<p><img loading="lazy" src="/images/2019/08/utlisation-wait-time.png" type="" alt=""  /></p>
<p>一个优秀的团队成员，需要在某种程度上遵循<code>UNIX</code>哲学中的一条原则：<em>每次仅完成一件事，并将其做到最好</em>。当然，这并不妨碍一个团队成员在很多方便都有优秀的技术专长，重点是：在每次任务重都专注的做好某一件事。</p>
<p>最有意思的是，在这种情况下，即使这位同事的主观意愿是好的，个人能力是出色的，但是从外部来度量整个团队的产出的话，其效率会低于平均水平中等，但是任务分配合理的团队。也就是说，在策略上有缺陷的<strong>忙</strong>事实上是在<strong>帮倒忙</strong>。</p>
<h3 id="祥林嫂式的抱怨">祥林嫂式的抱怨</h3>
<p>在我早年的一个项目上，在一个产品的研发进行到某一阶段后，团队进行了一次类似于<code>Bug Bash</code>的活动：收集产品中潜在的设计缺陷（包括可用性以及功能性的设计）。有一位同事从各个方面提出了近30条发现的“问题”，但是几乎没有给出一条有用的建议。基本上就是一副：<em>这个产品是个彻头彻尾的垃圾，而我也不知道怎么能把它变得更好</em>的心态。后来团队只好草草结束了这个有始无终的设计缺陷收集，而重新开始做一些<code>Up Front Design</code>。</p>
<p>在工作中这种人是非常容易招人厌恶的。一方面他们往往散发着浓郁的负能量，看着什么都充满怨念，另一方面，他不愿意或者不能够提出任何有效的改进方法。</p>
<p><img loading="lazy" src="/images/2019/08/bring-me-solutions.jpeg" type="" alt=""  /></p>
<p>应该注意到的是，提出问题 &ndash; 特别是不需要自己去费力解决的问题 &ndash; 是很容易的，而能想到可能的<em>解决方案</em>则相对困难。更进一步，想到一个直观的方案很容易，而给出<em>多个选项</em>，并对比各自的优劣则很困难。最后，如果你想要真正解决问题，或者让工作实际有所推进，那就需要尝试多做一些困难的事情（比如罗列并对比可能的方案，并给出可行的计划），并尝试简化他人的工作。</p>
<h3 id="眼高手低">眼高手低</h3>
<p>事实上，业界有很多<em>坐而论道</em>的大神。言必称高内聚、低耦合，动辄<code>S.O.L.I.D</code>，对各种编程范式更是如数家珍。但是具体到动手的时候，要么<em>顾左右而言他</em>，要么勉强写出几行未必能通过编译的代码，而内容则不忍卒读。</p>
<p>遇到这种情况，我会在他用鼠标哆哆嗦嗦的在文件列表里逐个找文件的时候把键盘抢过来，然后确保不让他碰键盘。如果心情好的话，我会规劝他多动手写一些代码。</p>
<p>要解决这个问题，方式其实并不复杂。胡适说：<em>多研究些问题，少谈些“主义”</em>。要我说，应该多写写业务代码，少谈些理论。我们都知道，在实践中，用<code>TDD</code>写个<code>FizzBuzz</code>是一回事儿；用相同的方法和原则把复杂的业务逻辑抽象并归类，则完全是另一件事儿。</p>
<p>这些人往往会混淆了<strong>知道</strong>和<strong>能做到</strong>间的界限，<em>知与行</em>并不统一。正如那个著名的画马的漫画所要表达的那样:</p>
<p><img loading="lazy" src="/images/2019/08/draw-a-horse.jpg" type="" alt=""  /></p>
<p>大部分情况下，我们缺少的不是用简笔画画出几个圆圈，而正是那些<strong>被轻视的细节</strong>。无论如何，我们的各种理论最终还是要体现在可以真正执行的软件代码上。</p>
<blockquote>
<p>Talk is cheap, show me the code.</p>
<p>Linus Torvalds</p>
</blockquote>
<p>一些可供参考的常见的技巧是：</p>
<ul>
<li>Code <a href="https://en.wikipedia.org/wiki/Kata_(programming)">kata</a></li>
<li>用脚本来<a href="http://icodeit.org/2017/01/why-top-programmers-hate-gui/">自动化一些常见任务</a></li>
<li>重构复杂的业务代码</li>
</ul>
<p>简而言之，坐而论道，不如作而行之。</p>
<h3 id="致命的舒适区">致命的舒适区</h3>
<p>这种人痛恨变化，这种情感可能来自于过往项目中引入新技术之后的负面的体验，或者纯粹的对新鲜事物兴趣的缺失，又或者二者兼而有之。总之你从他们口中经常听到的是诸如：“为什么不用redux”（因为redux我比较熟），或者为什么要用“Material-UI”（因为我不会）。事实上，这种情况甚至会发生在那些曾经热切而激进的技术人员身上。</p>
<p>大多数情况下，是他们没有勇气走出“舒适区”。他们误以为目前已经熟练掌握的技术永不过期，且是解决手头问题的最佳方案。然后现实是，没有什么是不变的。技术很快会过期，通常比我们想象的要快很多。</p>
<p>在我入职ThoughtWorks的时候，<code>RoR</code>是西安办公室的主流，前端的<code>Backbone+Jasmine</code>算是新的技术，而两年后一些团队开始零星的试点<code>Angular1.2</code>，<code>bower</code>，<code>PhantomJS</code>等，而如今这些技术都去哪儿了呢？<code>React+Redux</code>，<code>GraphQL</code>在很多场景下确实可以简化前端的工作，不过谁又知道下一个<code>breaking change</code>正在何处默默酝酿呢？</p>
<p><img loading="lazy" src="/images/2019/08/frontend-patterns.png" type="" alt=""  /></p>
<p>与<strong>固步自封</strong>相对的另一个极端是追逐一切新奇的事物，这样的做法亦不足取 &ndash; 它会浪费你大量的时间和精力在那些可能永远不会涉及的技术上。</p>
<p>尽管如此，我觉得作为开发者至少可以做的是：对新技术保持好奇和新鲜的态度，同时与其保持一定的距离。你未必需要在下一个项目中就采取<a href="https://github.com/trending">Github Trending</a>上的明星框架，但是花一些时间来保证自己了解其与同类产品的优劣对比，以及主要的应用场景等可以使你不至于在做技术决策时过于盲目和偏颇。</p>
<h3 id="后端返回的数据不对">后端返回的数据不对</h3>
<p>在有明确的前后端分工的团队中，前端开发负责界面的实现，同时消费后台API返回的数据，并可能做一些可能的数据格式化等；后端则负责于下游服务的交互，并组织数据供前端呈现。这种工作模式下的一个极端的情况是前后端仅仅通过契约来协作，一端对于另一端完全忽略并视之为黑盒。表面上来看，这种隔离在可以带来一些益处：前后两端的进度相对独立，互不影响。不过我始终怀疑这种机械的割裂真的可以带来它所承诺的好处。</p>
<p>不过其带来的问题往往非常显著：由于<em>延迟的集成导致延迟的价值交付</em>。更严重的是后果是人们会对于团队作为整体为结果负责这一根本问题的忽视，当出现问题时则往往互相指责。我听到太多次前端开发抱怨：“这个是后端API的问题”，或者“这个问题是后端没有处理网络超时所致”，而理所当然的将问题简化为“别人的问题”。</p>
<p><img loading="lazy" src="/images/2019/08/the-blame-game.jpg" type="" alt=""  /></p>
<p>“这是后端API的问题”这个描述本身是没有问题的，但是它不应该作为一个问题的结论，恰恰相反，它应该是进一步探索的开端：一个更系统的，更端到端的解决问题的方案的开端。这个描述可以指导物理上分离的两组同事一起面对问题，并找出适合当前架构的方案。</p>
<h3 id="历史遗留问题-legacy-problem">历史遗留问题 Legacy problem</h3>
<p>我常常看到有人抱怨自己工作的遗留代码如何如何糟糕，添加新功能如何如何困难等。当你尝试<code>challenge</code>他为何对这些问题不做出行动的时候，他会告诉你这些都是<em>历史原因</em> - 这段代码<em><strong>本来</strong></em>就是这样写的。</p>
<p>在实践中，这种情况往往和其他一些症状并行发作：</p>
<ul>
<li>不了解业务（没有意愿理解业务）</li>
<li>不了解技术决策（可能由于系统中缺乏诸如ADR的记录等）</li>
<li>重构能力欠缺</li>
<li>高层次的自动化测试缺失</li>
</ul>
<p>这种情况和“这是后端的问题”本质上可以算作同一类，都是尝试将自己置身事外，并将问题归因到另一些人（即使所谓的历史遗留代码就是他们自己写的）。如果说在某些情况下，比如后端是另一个团队，甚至是另一家公司提供的代码，“这是后端的问题”尚可作为一个借口的话，那么“历史遗留问题”的说法则是完全是无稽之谈。</p>
<p>这样的说法刻意的将自己描述成对<em>糟糕现状</em>无能为力的受害者，就好像是说，假如有一个理想的起点 &ndash; 比如让我从新开始写 &ndash; 他就一定可以做的比现在好。但是我们都知道，这种假设是未必成立的。事实上，当你决定要写点代码出来的那个时刻起，代码和架构就已经在准备腐坏了，除非你花费足够多的时间和精力去将其不断完善和修葺。而这正是事物的本性，并不随着人的客观意志为转移。</p>
<p>因此，压根不存在<em>历史遗留</em>问题这回事儿，它们只是<strong>普通问题</strong>。解决问题的第一步，永远是直面问题，认识到所谓的<em>历史遗留</em>问题是和我们将要开发的新需求，或者要修复的线上bug，以及刚刚<code>sign off</code>的卡上的一个微小变更并无二致。</p>
<p>简单来说，我们可以像故事墙那样维护一个技术债务板，并定期维护，按照工作量和价值来划分优先级，然后按部就班的将其消除。</p>
<p><img loading="lazy" src="/images/2019/08/idea-triage-matrix.png" type="" alt=""  /></p>
<p>我在很多遗留项目上工作过，有一些是接手时就已经存在了很长时间的老代码，另一些则是从头开始写但是随着需求的增加和改变而逐步腐化的。我发现行之有效的方法就是用对待老旧代码那样对待自己新写的代码 &ndash; 建立测试以形成安全网，做适度的重构（小到重命名一个变量，大到删除一个模块），并让代码比之前变好一点点。</p>
<p>当然，这需要整个团队每个成员都对代码质量有相类似的理解和足够的动手能力，同时也需要持续的投入心血和精力来维系。</p>
<h3 id="小结-summary">小结 Summary</h3>
<p>本文列举了一些我在各个项目中遇到的各种不靠谱的同事，包括内部和外部的一起工作的人们。甚至我自己在不同阶段也可能展现出这里列举的某些类型的特质。</p>
<ul>
<li>无法根据事情的重要/紧急程度划分优先级而导致自己疲于奔命的</li>
<li>只知道抱怨而不着手解决问题</li>
<li>能说不能做的</li>
<li>固步自封，不思进取</li>
<li>急于撇清责任，将自己置身事外</li>
<li>缺乏责任感，将问题归类到自己无法的力量的</li>
</ul>
<p>正如上面讨论过的，解决问题的第一步永远是承认并正视问题。唯有又勇气和魄力做到这一点，才可以接着讨论如何解决它们。如果仅仅列出问题而不讨论解决方案，那么我自己就变成了上述的“祥林嫂”式了。好在这些问题都可以通过技术手段消除（和上述问题依次对应）。</p>
<ul>
<li>按照价值决定优先级</li>
<li>通过刻意训练保持动手能力</li>
<li>抱怨之外，要顺带提出自己的观点（有备选方案更佳）</li>
<li>保持好奇心</li>
<li>通力合作而非互相指责</li>
<li>正视问题，并逐步解决</li>
</ul>
<h3 id="参考">参考</h3>
<ul>
<li><a href="https://medium.com/@christlc/slacking-off-at-work-is-a-demonstration-of-your-time-management-skill-proven-by-maths-f6529711cc70">Lead Time vs Utilization</a></li>
<li><a href="https://martinfowler.com/books/refactoring.html">Refactoring 2nd edition</a></li>
<li><a href="http://codekata.com/">Code Kata</a></li>
</ul>
]]></content:encoded>
    </item>
    
    <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>
    
  </channel>
</rss>
