atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

  <title><![CDATA[Mike Valenty]]></title>
  <link href="http://www.mikevalenty.com/atom.xml" rel="self"/>
  <link href="http://www.mikevalenty.com/"/>
  <updated>2015-05-10T07:33:58-07:00</updated>
  <id>http://www.mikevalenty.com/</id>
  <author>
    <name><![CDATA[Mike Valenty]]></name>
    <email><![CDATA[mike@valenty.com]]></email>
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[Scala Solution to Finding Happy Numbers]]></title>
    <link href="http://www.mikevalenty.com/scala-solution-to-finding-happy-numbers/"/>
    <updated>2015-05-03T10:45:00-07:00</updated>
    <id>http://www.mikevalenty.com/scala-solution-to-finding-happy-numbers</id>
    <content type="html"><![CDATA[<p>What is a Happy Number?</p>

<blockquote><p>Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1.</p>

<p><a href="http://en.wikipedia.org/wiki/Happy_number">http://en.wikipedia.org/wiki/Happy_number</a></p></blockquote>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="nd">@RunWith</span><span class="o">(</span><span class="n">classOf</span><span class="o">[</span><span class="kt">JUnitRunner</span><span class="o">])</span>
</span><span class='line'><span class="k">class</span> <span class="nc">HappyTests</span> <span class="k">extends</span> <span class="nc">FunSuite</span> <span class="k">with</span> <span class="nc">ShouldMatchers</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="n">happy</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Boolean</span> <span class="o">=</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">def</span> <span class="n">sumOfSquares</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">def</span> <span class="n">digits</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> <span class="k">=</span> <span class="k">if</span> <span class="o">(</span><span class="n">x</span> <span class="o">&lt;</span> <span class="mi">10</span><span class="o">)</span> <span class="nc">Seq</span><span class="o">(</span><span class="n">x</span><span class="o">)</span> <span class="k">else</span> <span class="n">digits</span><span class="o">(</span><span class="n">x</span> <span class="o">/</span> <span class="mi">10</span><span class="o">)</span> <span class="o">:+</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">10</span>
</span><span class='line'>      <span class="k">def</span> <span class="n">squared</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="n">x</span> <span class="o">*</span> <span class="n">x</span>
</span><span class='line'>      <span class="n">digits</span><span class="o">(</span><span class="n">x</span><span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="n">squared</span><span class="o">).</span><span class="n">sum</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">def</span> <span class="n">loop</span><span class="o">(</span><span class="n">seen</span><span class="k">:</span> <span class="kt">Set</span><span class="o">[</span><span class="kt">Int</span><span class="o">],</span> <span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Boolean</span> <span class="o">=</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">x</span> <span class="k">match</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">case</span> <span class="mi">1</span> <span class="k">=&gt;</span> <span class="kc">true</span>
</span><span class='line'>        <span class="k">case</span> <span class="k">_</span> <span class="k">if</span> <span class="n">seen</span><span class="o">.</span><span class="n">contains</span><span class="o">(</span><span class="n">x</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="kc">false</span>
</span><span class='line'>        <span class="k">case</span> <span class="k">_</span> <span class="k">=&gt;</span> <span class="n">loop</span><span class="o">(</span><span class="n">seen</span> <span class="o">+</span> <span class="n">x</span><span class="o">,</span> <span class="n">sumOfSquares</span><span class="o">(</span><span class="n">x</span><span class="o">))</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">loop</span><span class="o">(</span><span class="nc">Set</span><span class="o">(),</span> <span class="n">x</span><span class="o">)</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">test</span><span class="o">(</span><span class="s">&quot;happy numbers&quot;</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">val</span> <span class="n">actual</span> <span class="k">=</span> <span class="mi">1</span> <span class="n">to</span> <span class="mi">50</span> <span class="n">filter</span> <span class="n">happy</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">val</span> <span class="n">expected</span> <span class="k">=</span> <span class="nc">Seq</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="mi">7</span><span class="o">,</span> <span class="mi">10</span><span class="o">,</span> <span class="mi">13</span><span class="o">,</span> <span class="mi">19</span><span class="o">,</span> <span class="mi">23</span><span class="o">,</span> <span class="mi">28</span><span class="o">,</span> <span class="mi">31</span><span class="o">,</span> <span class="mi">32</span><span class="o">,</span> <span class="mi">44</span><span class="o">,</span> <span class="mi">49</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">actual</span> <span class="n">should</span> <span class="n">equal</span><span class="o">(</span><span class="n">expected</span><span class="o">)</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Scala Solution to Cheryl's Birthday Problem]]></title>
    <link href="http://www.mikevalenty.com/scala-solution-to-cheryls-birthday-problem/"/>
    <updated>2015-04-19T14:54:00-07:00</updated>
    <id>http://www.mikevalenty.com/scala-solution-to-cheryls-birthday-problem</id>
    <content type="html"><![CDATA[<p>I ran across a <a href="https://github.com/mad4j/puzzles/blob/master/src/dolmisani/puzzles/CherylBirthday.java">Java 8 solution</a> to <a href="http://www.nytimes.com/2015/04/15/science/a-math-problem-from-singapore-goes-viral-when-is-cheryls-birthday.html">Cheryl&rsquo;s birthday problem</a> and just had to write a Scala version since this is one of those problems the language was made for. Also, I&rsquo;ve been on the Java train for a few months and this was a good excuse to brush off the dust and work on my Scala chops.</p>

<h4>Cheryl&rsquo;s Birthday Problem</h4>

<blockquote><p>Albert and Bernard just become friends with Cheryl, and they want to know when her birthday is. Cheryl gives them a list of 10 possible dates.</p></blockquote>

<pre><code>May 15, May 16, May 19
June 17, June 18
July 14, July 16
August 14, August 15, August 17
</code></pre>

<blockquote><p>Cheryl then tells Albert and Bernard separately the month and the day of her birthday respectively.</p></blockquote>

<p><strong>Albert:</strong> I don’t know when Cheryl&rsquo;s birthday is, but I know that Bernard does not know too.</p>

<p><strong>Bernard:</strong> At first I don&rsquo;t know when Cheryl&rsquo;s birthday is, but I know now.</p>

<p><strong>Albert:</strong> Then I also know when Cheryl&rsquo;s birthday is.</p>

<p>So when is Cheryl’s birthday?</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="nd">@RunWith</span><span class="o">(</span><span class="n">classOf</span><span class="o">[</span><span class="kt">JUnitRunner</span><span class="o">])</span>
</span><span class='line'><span class="k">class</span> <span class="nc">BirthdayProblem</span> <span class="k">extends</span> <span class="nc">FunSuite</span> <span class="k">with</span> <span class="nc">ShouldMatchers</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">case</span> <span class="k">class</span> <span class="nc">Birthday</span><span class="o">(</span><span class="n">month</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">day</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">object</span> <span class="nc">Birthday</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">def</span> <span class="n">apply</span><span class="o">(</span><span class="n">s</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span><span class="k">:</span> <span class="kt">Birthday</span> <span class="o">=</span> <span class="n">s</span><span class="o">.</span><span class="n">split</span><span class="o">(</span><span class="s">&quot;-&quot;</span><span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="k">_</span><span class="o">.</span><span class="n">toInt</span><span class="o">)</span> <span class="k">match</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">case</span> <span class="nc">Array</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">d</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="nc">Birthday</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">d</span><span class="o">)</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">birthdays</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">]</span> <span class="k">=</span> <span class="nc">List</span><span class="o">(</span>
</span><span class='line'>    <span class="s">&quot;5-15&quot;</span><span class="o">,</span> <span class="s">&quot;5-16&quot;</span><span class="o">,</span> <span class="s">&quot;5-19&quot;</span><span class="o">,</span>
</span><span class='line'>    <span class="s">&quot;6-17&quot;</span><span class="o">,</span> <span class="s">&quot;6-18&quot;</span><span class="o">,</span>
</span><span class='line'>    <span class="s">&quot;7-14&quot;</span><span class="o">,</span> <span class="s">&quot;7-16&quot;</span><span class="o">,</span>
</span><span class='line'>    <span class="s">&quot;8-14&quot;</span><span class="o">,</span> <span class="s">&quot;8-15&quot;</span><span class="o">,</span> <span class="s">&quot;8-17&quot;</span>
</span><span class='line'>  <span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="nc">Birthday</span><span class="o">.</span><span class="n">apply</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="n">uniqueBy</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">K</span><span class="o">](</span><span class="n">fn</span><span class="k">:</span> <span class="o">(</span><span class="kt">A</span><span class="o">)</span> <span class="o">=&gt;</span> <span class="n">K</span><span class="o">)(</span><span class="n">b</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">def</span> <span class="n">groupSizeIs</span><span class="o">(</span><span class="n">size</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)(</span><span class="n">x</span><span class="k">:</span> <span class="o">(</span><span class="k">_</span><span class="o">,</span> <span class="kt">List</span><span class="o">[</span><span class="k">_</span><span class="o">]))</span> <span class="k">=</span> <span class="n">x</span><span class="o">.</span><span class="n">_2</span><span class="o">.</span><span class="n">size</span> <span class="o">==</span> <span class="n">size</span>
</span><span class='line'>    <span class="n">b</span><span class="o">.</span><span class="n">groupBy</span><span class="o">(</span><span class="n">fn</span><span class="o">).</span><span class="n">filter</span><span class="o">(</span><span class="n">groupSizeIs</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="n">flatMap</span><span class="o">(</span><span class="k">_</span><span class="o">.</span><span class="n">_2</span><span class="o">).</span><span class="n">toList</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">uniqueByDay</span><span class="k">:</span> <span class="o">(</span><span class="kt">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">])</span> <span class="k">=&gt;</span> <span class="nc">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">]</span> <span class="k">=</span> <span class="n">uniqueBy</span><span class="o">(</span><span class="k">_</span><span class="o">.</span><span class="n">day</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">uniqueByMonth</span><span class="k">:</span> <span class="o">(</span><span class="kt">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">])</span> <span class="k">=&gt;</span> <span class="nc">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">]</span> <span class="k">=</span> <span class="n">uniqueBy</span><span class="o">(</span><span class="k">_</span><span class="o">.</span><span class="n">month</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// Albert tells us that Bernard doesn&#39;t know the answer, so we</span>
</span><span class='line'>  <span class="c1">// know the answer must be in a month that does not contain a</span>
</span><span class='line'>  <span class="c1">// birthday with a unique day.</span>
</span><span class='line'>  <span class="k">val</span> <span class="n">clue1</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">val</span> <span class="n">monthsWithUniqueDay</span><span class="k">:</span> <span class="kt">Set</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> <span class="k">=</span> <span class="n">uniqueByDay</span><span class="o">(</span><span class="n">birthdays</span><span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="k">_</span><span class="o">.</span><span class="n">month</span><span class="o">).</span><span class="n">toSet</span>
</span><span class='line'>    <span class="n">birthdays</span><span class="o">.</span><span class="n">filterNot</span><span class="o">(</span><span class="n">b</span> <span class="k">=&gt;</span> <span class="n">monthsWithUniqueDay</span><span class="o">.</span><span class="n">contains</span><span class="o">(</span><span class="n">b</span><span class="o">.</span><span class="n">month</span><span class="o">))</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// Since Bernard now knows the answer, that tells us that the</span>
</span><span class='line'>  <span class="c1">// day must be unique among the remaining birthdays.</span>
</span><span class='line'>  <span class="k">val</span> <span class="n">clue2</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">]</span> <span class="k">=</span> <span class="n">uniqueByDay</span><span class="o">(</span><span class="n">clue1</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// Since Albert now knows the answer, that tells us the answer</span>
</span><span class='line'>  <span class="c1">// has to be unique by month.</span>
</span><span class='line'>  <span class="k">val</span> <span class="n">clue3</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">Birthday</span><span class="o">]</span> <span class="k">=</span> <span class="n">uniqueByMonth</span><span class="o">(</span><span class="n">clue2</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// The only remaining birthday is the answer.</span>
</span><span class='line'>  <span class="k">val</span> <span class="n">answer</span> <span class="k">=</span> <span class="n">clue3</span><span class="o">.</span><span class="n">head</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">test</span><span class="o">(</span><span class="s">&quot;Cheryl&#39;s birthday&quot;</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">answer</span> <span class="n">should</span> <span class="n">equal</span><span class="o">(</span><span class="nc">Birthday</span><span class="o">(</span><span class="s">&quot;xx-xx&quot;</span><span class="o">))</span> <span class="c1">// REDACTED</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Yay.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Unit Testing Scalding Jobs]]></title>
    <link href="http://www.mikevalenty.com/unit-testing-scalding-jobs/"/>
    <updated>2014-03-15T15:27:00-07:00</updated>
    <id>http://www.mikevalenty.com/unit-testing-scalding-jobs</id>
    <content type="html"><![CDATA[<p><a href="https://github.com/twitter/scalding">Scalding</a> is a powerful framework for writing complex data processing applications on Apache Hadoop. It&rsquo;s concise and expressive - almost to a fault. It&rsquo;s dangerously easy to pack gobs of subtle business logic into just a few lines of code. If you&rsquo;re writing real data processing applications and not just ad-hoc reports, unit testing is a must. However tests can get unwieldy to manage as job complexity grows and the arity of data increases.</p>

<p>For example, consider this scalding job:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">class</span> <span class="nc">ComplicatedJob</span><span class="o">(</span><span class="n">args</span><span class="k">:</span> <span class="kt">Args</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">Job</span><span class="o">(</span><span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">bloatedTsv</span> <span class="k">=</span> <span class="nc">Tsv</span><span class="o">(</span><span class="s">&quot;input&quot;</span><span class="o">,</span>
</span><span class='line'>    <span class="o">(</span><span class="-Symbol">&#39;user_id</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;timestamp</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;host</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;referer</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;remote_addr</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;user_agent</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;cookie</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;connection</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;accept_encoding</span><span class="o">,</span>
</span><span class='line'>      <span class="-Symbol">&#39;accept_language</span><span class="o">)).</span><span class="n">read</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">bloatedTsv</span>
</span><span class='line'>    <span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="-Symbol">&#39;timestamp</span> <span class="o">-&gt;</span> <span class="-Symbol">&#39;timestamp</span><span class="o">)</span> <span class="o">{</span> <span class="n">ts</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=&gt;</span> <span class="n">toDateTime</span><span class="o">(</span><span class="n">ts</span><span class="o">)</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">.</span><span class="n">filter</span><span class="o">(</span><span class="-Symbol">&#39;timestamp</span><span class="o">)</span> <span class="o">{</span> <span class="n">ts</span><span class="k">:</span> <span class="kt">DateTime</span> <span class="o">=&gt;</span> <span class="n">ts</span><span class="o">.</span><span class="n">isAfter</span><span class="o">(</span><span class="nc">DateTime</span><span class="o">.</span><span class="n">now</span><span class="o">.</span><span class="n">minusDays</span><span class="o">(</span><span class="mi">30</span><span class="o">))</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="-Symbol">&#39;user_agent</span> <span class="o">-&gt;</span> <span class="-Symbol">&#39;browser</span><span class="o">)</span> <span class="o">{</span> <span class="n">userAgent</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=&gt;</span> <span class="n">toBrowser</span><span class="o">(</span><span class="n">userAgent</span><span class="o">)</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="-Symbol">&#39;remote_addr</span> <span class="o">-&gt;</span> <span class="-Symbol">&#39;country</span><span class="o">)</span> <span class="o">{</span> <span class="n">ip</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=&gt;</span> <span class="n">toCountry</span><span class="o">(</span><span class="n">ip</span><span class="o">)</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="-Symbol">&#39;country</span> <span class="o">-&gt;</span> <span class="-Symbol">&#39;country</span><span class="o">)</span> <span class="o">{</span> <span class="n">c</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=&gt;</span> <span class="k">if</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="s">&quot;us&quot;</span><span class="o">)</span> <span class="n">c</span> <span class="k">else</span> <span class="s">&quot;other&quot;</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">.</span><span class="n">groupBy</span><span class="o">(</span><span class="-Symbol">&#39;browser</span><span class="o">,</span> <span class="-Symbol">&#39;country</span><span class="o">)</span> <span class="o">{</span> <span class="k">_</span><span class="o">.</span><span class="n">size</span><span class="o">(</span><span class="-Symbol">&#39;count</span><span class="o">)</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">.</span><span class="n">groupBy</span><span class="o">(</span><span class="-Symbol">&#39;browser</span><span class="o">)</span> <span class="o">{</span> <span class="k">_</span><span class="o">.</span><span class="n">pivot</span><span class="o">((</span><span class="-Symbol">&#39;country</span><span class="o">,</span> <span class="-Symbol">&#39;count</span><span class="o">)</span> <span class="o">-&gt;(</span><span class="-Symbol">&#39;us</span><span class="o">,</span> <span class="-Symbol">&#39;other</span><span class="o">))</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">.</span><span class="n">write</span><span class="o">(</span><span class="nc">Tsv</span><span class="o">(</span><span class="s">&quot;output&quot;</span><span class="o">))</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="n">toDateTime</span><span class="o">(</span><span class="n">ts</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span><span class="k">:</span> <span class="kt">DateTime</span> <span class="o">=</span> <span class="o">{</span> <span class="o">...</span> <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">...</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Testing this job end-to-end would be fragile because there is so much going on and it would be tedious and noisy to build fake data to isolate and highlight edge cases. The pivot operations on lines 20-22 only deal with <code>browser</code> and <code>country</code> yet test data with all 10 fields is required including valid timestamps and user agents just to get to the pivot logic.</p>

<p> There are a few ways to tackle this and an approach I like is to use extension methods to breakdown the logic into smaller chunks of testable code. The result might look something like this.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">class</span> <span class="nc">ComplicatedJob</span><span class="o">(</span><span class="n">args</span><span class="k">:</span> <span class="kt">Args</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">Job</span><span class="o">(</span><span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">...</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">bloatedTsv</span>
</span><span class='line'>    <span class="o">.</span><span class="n">timestampIsAfter</span><span class="o">(</span><span class="nc">DateTime</span><span class="o">.</span><span class="n">now</span><span class="o">.</span><span class="n">minusDays</span><span class="o">(</span><span class="mi">30</span><span class="o">))</span>
</span><span class='line'>    <span class="o">.</span><span class="n">userAgentToBrowser</span><span class="o">()</span>
</span><span class='line'>    <span class="o">.</span><span class="n">remoteAddrToCountry</span><span class="o">()</span>
</span><span class='line'>    <span class="o">.</span><span class="n">countCountryByBrowser</span><span class="o">()</span>
</span><span class='line'>    <span class="o">.</span><span class="n">write</span><span class="o">(</span><span class="nc">Tsv</span><span class="o">(</span><span class="s">&quot;output&quot;</span><span class="o">))</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Each block of code depends on only a few fields so it doesn&rsquo;t require mocking the entire input set.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">import</span> <span class="nn">Dsl._</span>
</span><span class='line'>
</span><span class='line'><span class="k">object</span> <span class="nc">ComplicatedJob</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">implicit</span> <span class="k">class</span> <span class="nc">ComplicatedJobRichPipe</span><span class="o">(</span><span class="n">pipe</span><span class="k">:</span> <span class="kt">Pipe</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// this chunk of code is testable in isolation</span>
</span><span class='line'>    <span class="k">def</span> <span class="n">countCountryByBrowser</span><span class="o">()</span><span class="k">:</span> <span class="kt">Pipe</span> <span class="o">=</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">pipe</span>
</span><span class='line'>        <span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="-Symbol">&#39;country</span> <span class="o">-&gt;</span> <span class="-Symbol">&#39;country</span><span class="o">)</span> <span class="o">{</span> <span class="n">c</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=&gt;</span> <span class="k">if</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="s">&quot;us&quot;</span><span class="o">)</span> <span class="n">c</span> <span class="k">else</span> <span class="s">&quot;other&quot;</span> <span class="o">}</span>
</span><span class='line'>        <span class="o">.</span><span class="n">groupBy</span><span class="o">(</span><span class="-Symbol">&#39;browser</span><span class="o">,</span> <span class="-Symbol">&#39;country</span><span class="o">)</span> <span class="o">{</span> <span class="k">_</span><span class="o">.</span><span class="n">size</span><span class="o">(</span><span class="-Symbol">&#39;count</span><span class="o">)</span> <span class="o">}</span>
</span><span class='line'>        <span class="o">.</span><span class="n">groupBy</span><span class="o">(</span><span class="-Symbol">&#39;browser</span><span class="o">)</span> <span class="o">{</span> <span class="k">_</span><span class="o">.</span><span class="n">pivot</span><span class="o">((</span><span class="-Symbol">&#39;country</span><span class="o">,</span> <span class="-Symbol">&#39;count</span><span class="o">)</span> <span class="o">-&gt;(</span><span class="-Symbol">&#39;us</span><span class="o">,</span> <span class="-Symbol">&#39;other</span><span class="o">))</span> <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="o">...</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>In this example only <code>browser</code> and <code>country</code> are required so setting up test data is reasonably painless and the intent of the test case isn&rsquo;t lost in a sea of tuples. Granted, this approach requires creating a helper job to set up the input and capture the output for test assertions, but I think it&rsquo;s a worthwhile trade off to reveal such a clear test case.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
<span class='line-number'>53</span>
<span class='line-number'>54</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">import</span> <span class="nn">ComplicatedJob._</span>
</span><span class='line'><span class="k">import</span> <span class="nn">ComplicatedJobTests._</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@RunWith</span><span class="o">(</span><span class="n">classOf</span><span class="o">[</span><span class="kt">JUnitRunner</span><span class="o">])</span>
</span><span class='line'><span class="k">class</span> <span class="nc">ComplicatedJobTests</span> <span class="k">extends</span> <span class="nc">FunSuite</span> <span class="k">with</span> <span class="nc">ShouldMatchers</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">test</span><span class="o">(</span><span class="s">&quot;should count and pivot rows into columns&quot;</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">val</span> <span class="n">input</span> <span class="k">=</span> <span class="nc">List</span><span class="o">[</span><span class="kt">InputTuple</span><span class="o">](</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;firefox&quot;</span><span class="o">,</span> <span class="s">&quot;us&quot;</span><span class="o">),</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;chrome&quot;</span><span class="o">,</span> <span class="s">&quot;us&quot;</span><span class="o">),</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;safari&quot;</span><span class="o">,</span> <span class="s">&quot;us&quot;</span><span class="o">),</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;firefox&quot;</span><span class="o">,</span> <span class="s">&quot;us&quot;</span><span class="o">),</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;firefox&quot;</span><span class="o">,</span> <span class="s">&quot;br&quot;</span><span class="o">),</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;chrome&quot;</span><span class="o">,</span> <span class="s">&quot;de&quot;</span><span class="o">)</span>
</span><span class='line'>    <span class="o">)</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">val</span> <span class="n">expected</span> <span class="k">=</span> <span class="nc">Set</span><span class="o">[</span><span class="kt">OutputTuple</span><span class="o">](</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;firefox&quot;</span><span class="o">,</span> <span class="mi">2</span><span class="o">,</span> <span class="mi">1</span><span class="o">),</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;safari&quot;</span><span class="o">,</span> <span class="mi">1</span><span class="o">,</span> <span class="mi">0</span><span class="o">),</span>
</span><span class='line'>      <span class="o">(</span><span class="s">&quot;chrome&quot;</span><span class="o">,</span> <span class="mi">1</span><span class="o">,</span> <span class="mi">1</span><span class="o">)</span>
</span><span class='line'>    <span class="o">)</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">count</span><span class="o">(</span><span class="n">input</span><span class="o">)</span> <span class="o">{</span> <span class="k">_</span><span class="o">.</span><span class="n">toSet</span> <span class="n">should</span> <span class="n">equal</span><span class="o">(</span><span class="n">expected</span><span class="o">)</span> <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">object</span> <span class="nc">ComplicatedJobTests</span> <span class="o">{</span>
</span><span class='line'>  <span class="k">type</span> <span class="kt">InputTuple</span> <span class="o">=</span> <span class="o">(</span><span class="nc">String</span><span class="o">,</span> <span class="nc">String</span><span class="o">)</span>
</span><span class='line'>  <span class="k">type</span> <span class="kt">OutputTuple</span> <span class="o">=</span> <span class="o">(</span><span class="nc">String</span><span class="o">,</span> <span class="nc">Int</span><span class="o">,</span> <span class="nc">Int</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// this is a helper job to set up the inputs and outputs</span>
</span><span class='line'>  <span class="c1">// for the chunk of code we&#39;re trying to test</span>
</span><span class='line'>  <span class="k">class</span> <span class="nc">CountCountryByBrowser</span><span class="o">(</span><span class="n">args</span><span class="k">:</span> <span class="kt">Args</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">Job</span><span class="o">(</span><span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="nc">Tsv</span><span class="o">(</span><span class="s">&quot;input&quot;</span><span class="o">,</span> <span class="o">(</span><span class="-Symbol">&#39;browser</span><span class="o">,</span> <span class="-Symbol">&#39;country</span><span class="o">))</span>
</span><span class='line'>      <span class="o">.</span><span class="n">read</span>
</span><span class='line'>      <span class="o">.</span><span class="n">countCountryByBrowser</span><span class="o">()</span> <span class="c1">// this is what we&#39;re testing</span>
</span><span class='line'>      <span class="o">.</span><span class="n">project</span><span class="o">(</span><span class="-Symbol">&#39;browser</span><span class="o">,</span> <span class="-Symbol">&#39;us</span><span class="o">,</span> <span class="-Symbol">&#39;other</span><span class="o">)</span>
</span><span class='line'>      <span class="o">.</span><span class="n">write</span><span class="o">(</span><span class="nc">Tsv</span><span class="o">(</span><span class="s">&quot;output&quot;</span><span class="o">))</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// helper method to run our test job</span>
</span><span class='line'>  <span class="k">def</span> <span class="n">count</span><span class="o">(</span><span class="n">input</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">InputTuple</span><span class="o">])(</span><span class="n">fn</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">OutputTuple</span><span class="o">]</span> <span class="k">=&gt;</span> <span class="nc">Unit</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">import</span> <span class="nn">Dsl._</span>
</span><span class='line'>    <span class="nc">JobTest</span><span class="o">[</span><span class="kt">CountCountryByBrowser</span><span class="o">]</span>
</span><span class='line'>      <span class="o">.</span><span class="n">source</span><span class="o">(</span><span class="nc">Tsv</span><span class="o">(</span><span class="s">&quot;input&quot;</span><span class="o">,</span> <span class="o">(</span><span class="-Symbol">&#39;browser</span><span class="o">,</span> <span class="-Symbol">&#39;country</span><span class="o">)),</span> <span class="n">input</span><span class="o">)</span>
</span><span class='line'>      <span class="o">.</span><span class="n">sink</span><span class="o">[</span><span class="kt">OutputTuple</span><span class="o">](</span><span class="nc">Tsv</span><span class="o">(</span><span class="s">&quot;output&quot;</span><span class="o">))</span> <span class="o">{</span> <span class="n">b</span> <span class="k">=&gt;</span> <span class="n">fn</span><span class="o">(</span><span class="n">b</span><span class="o">.</span><span class="n">toList</span><span class="o">)</span> <span class="o">}</span>
</span><span class='line'>      <span class="o">.</span><span class="n">run</span>
</span><span class='line'>      <span class="o">.</span><span class="n">finish</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Parsing Json With Defaults in Scala]]></title>
    <link href="http://www.mikevalenty.com/parsing-json-with-defaults-in-scala/"/>
    <updated>2014-01-24T22:57:00-08:00</updated>
    <id>http://www.mikevalenty.com/parsing-json-with-defaults-in-scala</id>
    <content type="html"><![CDATA[<p>The <a href="http://www.playframework.com/documentation/2.2.x/ScalaJson">json library in Play</a> does this thing where it explodes if the json you&rsquo;re reading is missing a property. <a href="https://code.google.com/p/google-gson/">Gson</a> would happily leave the property null, but that&rsquo;s just not the scala way. In scala, if something is optional, it&rsquo;s wrapped in an <code>Option</code>. The problem is I&rsquo;d like to add a property to my data model and I don&rsquo;t want it to be optional because it&rsquo;s not.</p>

<p>In Java land, I probably would have added the property and thought about how to deal with migrating old data later, but not in scala. This battle has to be fought right now. That&rsquo;s what <em>type safe</em> means and it&rsquo;s why the <code>NullPointerException</code> has all but died in pure scala apps, not unlike the <a href="http://freakonomics.com/2013/09/12/whatever-happened-to-the-carpal-tunnel-epidemic/">carpal tunnel epidemic</a>.</p>

<p>In my case I&rsquo;ve got some data in Couchbase and when I add a new property to my data model, I won&rsquo;t be able to read the old data. What I need to do is transform the json before hydrating the object. Fortunately, this is a snap by using the rich transformation features described in <a href="http://mandubian.com/2013/01/13/JSON-Coast-to-Coast/">JSON Coast-to-Coast</a>.</p>

<p>My approach was to create a subclass of <code>Reads[A]</code> called <code>ReadsWithDefaults[A]</code> that reads json and uses a transformation to merge default values. It looks like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">case</span> <span class="k">class</span> <span class="nc">MyObject</span><span class="o">(</span><span class="n">color</span><span class="k">:</span> <span class="kt">String</span><span class="o">,</span> <span class="n">shape</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'><span class="k">object</span> <span class="nc">MyObject</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">val</span> <span class="n">defaults</span> <span class="k">=</span> <span class="nc">MyObject</span><span class="o">(</span><span class="s">&quot;blue&quot;</span><span class="o">,</span> <span class="s">&quot;square&quot;</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">implicit</span> <span class="k">val</span> <span class="n">readsMyObject</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">ReadsWithDefaults</span><span class="o">(</span><span class="n">defaults</span><span class="o">)(</span><span class="nc">Json</span><span class="o">.</span><span class="n">format</span><span class="o">[</span><span class="kt">MyObject</span><span class="o">])</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">implicit</span> <span class="k">val</span> <span class="n">writesMyObject</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Json</span><span class="o">.</span><span class="n">writes</span><span class="o">[</span><span class="kt">MyObject</span><span class="o">]</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">import</span> <span class="nn">play.api.libs.json._</span>
</span><span class='line'><span class="k">import</span> <span class="nn">play.api.libs.json.Reads._</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">ReadsWithDefaults</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">defaults</span><span class="k">:</span> <span class="kt">A</span><span class="o">)(</span><span class="k">implicit</span> <span class="n">format</span><span class="k">:</span> <span class="kt">Format</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span> <span class="k">extends</span> <span class="nc">Reads</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">private</span> <span class="k">val</span> <span class="n">mergeWithDefaults</span> <span class="k">=</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">val</span> <span class="n">defaultJson</span> <span class="k">=</span> <span class="nc">Json</span><span class="o">.</span><span class="n">fromJson</span><span class="o">[</span><span class="kt">JsObject</span><span class="o">](</span><span class="nc">Json</span><span class="o">.</span><span class="n">toJson</span><span class="o">(</span><span class="n">defaults</span><span class="o">)).</span><span class="n">get</span>
</span><span class='line'>    <span class="nc">__</span><span class="o">.</span><span class="n">json</span><span class="o">.</span><span class="n">update</span><span class="o">(</span><span class="n">of</span><span class="o">[</span><span class="kt">JsObject</span><span class="o">]</span> <span class="n">map</span> <span class="o">{</span><span class="n">o</span> <span class="k">=&gt;</span> <span class="n">defaultJson</span> <span class="o">++</span> <span class="n">o</span><span class="o">})</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="n">reads</span><span class="o">(</span><span class="n">json</span><span class="k">:</span> <span class="kt">JsValue</span><span class="o">)</span> <span class="k">=</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">val</span> <span class="n">jsObject</span> <span class="k">=</span> <span class="n">json</span><span class="o">.</span><span class="n">transform</span><span class="o">(</span><span class="n">mergeWithDefaults</span><span class="o">).</span><span class="n">get</span>
</span><span class='line'>    <span class="nc">Json</span><span class="o">.</span><span class="n">fromJson</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">jsObject</span><span class="o">)(</span><span class="n">format</span><span class="o">)</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>



]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Web Framework Scaffolding Considered Harmful]]></title>
    <link href="http://www.mikevalenty.com/web-framework-scaffolding-considered-harmful/"/>
    <updated>2014-01-02T09:59:00-08:00</updated>
    <id>http://www.mikevalenty.com/web-framework-scaffolding-considered-harmful</id>
    <content type="html"><![CDATA[<p>If you&rsquo;re a start up and spending time building back office tools to input application data into web forms, you&rsquo;re doing it wrong. Sure, it&rsquo;s a pretty simple task to build a few <a href="http://en.wikipedia.org/wiki/Create,_read,_update_and_delete">CRUD</a> screens using the hottest new MVC framework, but you can do better.</p>

<p>Integrating with Google spreadsheets to manage application data unlocks powerful possibilities and will take you further than anything you could scaffold up in a comperable amount of time. To be clear, I&rsquo;m not suggesting you take a <em>runtime</em> dependency on Google docs. I&rsquo;m talking about using a lightweight business process that takes advantage of the rich collaborations features of Google docs and simply <em>import</em> the data into your database using the <a href="https://developers.google.com/google-apps/spreadsheets/">API</a>.</p>

<p><img src="http://www.mikevalenty.com/images/posts/example_sp3.png" width="600"></p>

<div style="clear:both;"></div>


<h3>Revision history</h3>

<p><img class="right" src="http://www.mikevalenty.com/images/posts/example_rev.png" width="300"></p>

<p>Google docs keeps a revision history of what was changed, when and by whom. That&rsquo;s a pretty cool feature and one you&rsquo;re not likely to build when there are more pressing customer facing features to work on.</p>

<p>Sometimes release notes aren&rsquo;t detailed enough when trying to correlate a surprising change in a KPI, so it&rsquo;s reassuring to have the nitty gritty revision history there when you need to dig a little deeper. It&rsquo;s just like reviewing source control history when tracking down a bug that was introduced in the latest code release. Your data deserves the same respect.</p>

<h3>Concurrent editing</h3>

<p>My older brother carries a pocket knife at all times, and when he believes in something, he can&rsquo;t help but sell everyone else on the idea. He used to tell me I needed to carry a pocket knife so I could cut off my seatbelt when trapped in a burning (or sinking) car. In his defense, <a href="http://money.cnn.com/2010/08/17/autos/gm_recall/index.htm">GM recalled 240,000 SUVs in 2010</a> citing &ldquo;&hellip;[the seat belt] may seem to be jammed.&rdquo;</p>

<p>Naturally, I started carrying a pocket knife too. I figured that along with untrapping myself from a burning car or defending myself at an ATM, it would be handy when I needed to open a box. To my surprise, new opportunities presented themselves and I was using my knife several times a day. I could cut off a hanging thread, scrape bee pollen off my windsheild, improve the vent in my coffee lid, remove a scratchy tag from my son&rsquo;s shirt and yes, open a box.</p>

<p>It turns out I had a similar experience with concurrent editing. Working on the same document at the same time with multiple people is pretty cool, and you&rsquo;d be surprised how this powerful ability can change the way you work. There&rsquo;s no way you would justify an extravagant feature like this in your own back office tools and you get it for free with Google docs.</p>

<h3>Formulas</h3>

<p>Since it&rsquo;s a spreadsheet, you can use formulas and this is cooler than you might think. Consider a list of products. Chances are the product prices have some kind of relationship that you can capture with a formula and save yourself from tedious and error prone manual entry.</p>

<p>In reality though, you probably don&rsquo;t care about the actual product prices as much as you care about your margins or some other derived number. With a spreadsheet, you can keep your formula together with your data. When you change a price, you can see how it affects your bottom line in a calculated field a few cells over. Or work backwards and calculate the price based on a combination of other factors. Or just use a forumla as a sanity check that all your numbers add up to the right amount.</p>

<p>Again, this is the kind of feature that invites new ways of working. You might use a formula to find a bug before the data ever hits your app or add a new forumla so you don&rsquo;t get burned twice by the same mistake. A spreadsheet gives you a place to capture knowledge about your data. You could capture this knowledge in a wiki, but the fact that it&rsquo;s in a Google spreadsheet that&rsquo;s connected to your app, makes it real. It&rsquo;s the difference between a code comment and a unit test.</p>

<h3>Import</h3>

<p><img class="right" src="http://www.mikevalenty.com/images/posts/example_dup.png" width="300"></p>

<p>A data update is a deployment just like a code deployment and things can go horribly wrong when there&rsquo;s a mistake in your data. Big companies get this and respond with change advisory boards and more process to protect themselves, but you can do better.</p>

<p>Your data deserves a repeatable one-click deployment process and you shouldn&rsquo;t settle for anything less. An import is <a href="http://en.wikipedia.org/wiki/Idempotence">idempotent</a> which means you can run it multiple times and the end result is always the same. In other words, you can practice in a test environment and iterate until you get it right. Oh, and if you spin off a copy prior to making changes, you get one-click rollback too.</p>

<h2>Conclusion</h2>

<p>One-click deployment and rollback with revision history for your data without developer interaction. That&rsquo;s a really big deal because the end result is confidence. Confidence means that as an organization, you can make decisions, execute and not look back.</p>

<p>Empower your team (not just developers) with a familiar tool like a spreadsheet and give them the opportunity to impress you. Watch as calculations and charts emerge to add deeper meaning to your data. Watch as collaboration occurs and team members are brought together rather than divided by functional roles. Watch as confidence increases in your ability to deploy changes.</p>

<p>Seriously. Don&rsquo;t waste your time half-assing back office tools when you can invest a similar amount of effort to import data from Google spreadsheets. It&rsquo;s a scrappy tool that delivers on the features that accelerate the way you work.</p>

<div style="clear:both;"></div>


<blockquote><p>If you can do a half-assed job of anything, you’re a one-eyed man in a kingdom of the blind. – Kurt Vonnegut</p></blockquote>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Using Scala to Perform a Multi-Key Get on a Couchbase View]]></title>
    <link href="http://www.mikevalenty.com/using-scala-to-perform-a-multi-key-get-on-a-couchbase-view/"/>
    <updated>2013-11-16T15:26:00-08:00</updated>
    <id>http://www.mikevalenty.com/using-scala-to-perform-a-multi-key-get-on-a-couchbase-view</id>
    <content type="html"><![CDATA[<p>To retrieve documents from Couchbase by anything other than the document key requires querying a <a href="http://www.couchbase.com/docs//couchbase-manual-2.0/couchbase-views.html">view</a> and views are defined by map and reduce functions written in JavaScript. Consider a view that returns data like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="nx">key</span>         <span class="nx">value</span>
</span><span class='line'><span class="o">---</span>         <span class="o">-----</span>
</span><span class='line'><span class="s2">&quot;key1&quot;</span>      <span class="p">{</span> <span class="s2">&quot;term&quot;</span><span class="o">:</span> <span class="s2">&quot;red&quot;</span><span class="p">,</span> <span class="s2">&quot;count&quot;</span><span class="o">:</span> <span class="mi">2</span> <span class="p">}</span>
</span><span class='line'><span class="s2">&quot;key2&quot;</span>      <span class="p">{</span> <span class="s2">&quot;term&quot;</span><span class="o">:</span> <span class="s2">&quot;red&quot;</span><span class="p">,</span> <span class="s2">&quot;count&quot;</span><span class="o">:</span> <span class="mi">1</span> <span class="p">}</span>
</span><span class='line'><span class="s2">&quot;key3&quot;</span>      <span class="p">{</span> <span class="s2">&quot;term&quot;</span><span class="o">:</span> <span class="s2">&quot;blue&quot;</span><span class="p">,</span> <span class="s2">&quot;count&quot;</span><span class="o">:</span> <span class="mi">4</span> <span class="p">}</span>
</span><span class='line'><span class="p">...</span>
</span></code></pre></td></tr></table></div></figure>


<p>And this Scala <code>case class</code> to hold the documents retrieved from the view.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">case</span> <span class="k">class</span> <span class="nc">TermOccurrence</span><span class="o">(</span><span class="n">term</span><span class="k">:</span> <span class="kt">String</span><span class="o">,</span> <span class="n">count</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span>
</span></code></pre></td></tr></table></div></figure>


<p>It&rsquo;s a common scenario to retrieve multiple documents at once and the <a href="http://www.couchbase.com/communities/java/getting-started">Java driver</a> has a pretty straight forward api for that. The desired keys are simply specified as a json array.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">import</span> <span class="nn">com.couchbase.client.CouchbaseClient</span>
</span><span class='line'><span class="k">import</span> <span class="nn">play.api.libs.json.Json</span>
</span><span class='line'><span class="k">import</span> <span class="nn">CouchbaseExtensions._</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Log</span>
</span><span class='line'><span class="k">def</span> <span class="n">findByTerms</span><span class="o">(</span><span class="n">terms</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">String</span><span class="o">])</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">TermOccurrence</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">keys</span> <span class="k">=</span> <span class="nc">Json</span><span class="o">.</span><span class="n">stringify</span><span class="o">(</span><span class="nc">Json</span><span class="o">.</span><span class="n">toJson</span><span class="o">(</span><span class="n">terms</span> <span class="n">map</span> <span class="o">(</span><span class="k">_</span><span class="o">.</span><span class="n">toLowerCase</span><span class="o">)))</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">view</span> <span class="k">=</span> <span class="n">client</span><span class="o">.</span><span class="n">getView</span><span class="o">(</span><span class="s">&quot;view1&quot;</span><span class="o">,</span> <span class="s">&quot;by_term&quot;</span><span class="o">)</span>
</span><span class='line'>  <span class="k">val</span> <span class="n">query</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Query</span><span class="o">()</span>
</span><span class='line'>  <span class="n">query</span><span class="o">.</span><span class="n">setIncludeDocs</span><span class="o">(</span><span class="kc">false</span><span class="o">)</span>
</span><span class='line'>  <span class="n">query</span><span class="o">.</span><span class="n">setKeys</span><span class="o">(</span><span class="n">keys</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">response</span> <span class="k">=</span> <span class="n">client</span><span class="o">.</span><span class="n">query</span><span class="o">(</span><span class="n">view</span><span class="o">,</span> <span class="n">query</span><span class="o">).</span><span class="n">asScala</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">response</span><span class="o">.</span><span class="n">toList</span> <span class="n">map</span> <span class="o">(</span><span class="k">_</span><span class="o">.</span><span class="n">as</span><span class="o">[</span><span class="kt">TermOccurrence</span><span class="o">])</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The Java driver deals with strings so it&rsquo;s up to the client application to handle the json parsing. That was an excellent design decision and makes using the Java driver from Scala pretty painless. I&rsquo;m using the <a href="http://www.playframework.com/">Play Framework</a> json libraries and an extension method <code>_.as[TermOccurrence]</code> defined on <code>ViewRow</code> to simplify the mapping of the response documents to Scala objects.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">object</span> <span class="nc">CouchbaseExtensions</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">implicit</span> <span class="k">class</span> <span class="nc">RichViewRow</span><span class="o">(</span><span class="n">row</span><span class="k">:</span> <span class="kt">ViewRow</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">def</span> <span class="n">as</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="k">implicit</span> <span class="n">format</span><span class="k">:</span> <span class="kt">Format</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">val</span> <span class="n">document</span> <span class="k">=</span> <span class="n">row</span><span class="o">.</span><span class="n">getValue</span>
</span><span class='line'>      <span class="k">val</span> <span class="n">modelJsValue</span> <span class="k">=</span> <span class="nc">Json</span><span class="o">.</span><span class="n">parse</span><span class="o">(</span><span class="n">document</span><span class="o">)</span>
</span><span class='line'>      <span class="nc">Json</span><span class="o">.</span><span class="n">fromJson</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">modelJsValue</span><span class="o">).</span><span class="n">get</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>In order for this extension method to work, it requires an implicit <code>Format[TermOccurrence]</code> which is defined on of the <code>TermOccurrence</code> compainion object.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">object</span> <span class="nc">TermOccurrence</span> <span class="o">{</span>
</span><span class='line'>  <span class="k">implicit</span> <span class="k">val</span> <span class="n">formatTermOccurrence</span> <span class="k">=</span> <span class="nc">Json</span><span class="o">.</span><span class="n">format</span><span class="o">[</span><span class="kt">TermOccurrence</span><span class="o">]</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Hadoop MapReduce Join Optimization With a Bloom Filter]]></title>
    <link href="http://www.mikevalenty.com/hadoop-mapreduce-join-optimization-with-a-bloom-filter/"/>
    <updated>2013-10-15T22:49:00-07:00</updated>
    <id>http://www.mikevalenty.com/hadoop-mapreduce-join-optimization-with-a-bloom-filter</id>
    <content type="html"><![CDATA[<p>Doing a join in hadoop with Java is painful. A one-liner in <a href="http://pig.apache.org/">Pig Latin</a> can easily explode into hundreds of lines of Java. However, the additional control in Java can yield significant performance gains and simplify complex logic that is difficult to express in Pig Latin.</p>

<p>In my case, the left side of the join contained about 100K records while the right side was closer to 1B. Emitting all join keys from the mapper means that all 1B records from the right side of the join are shuffled, sorted and sent to a reducer. The reducer then ends up discarding most of join keys that don&rsquo;t match the left side.</p>

<p>Any best practices guide will tell you to push more work into the mapper. In the case of a join, that means dropping records in the mapper that will end up getting dropped by the reducer anyway. In order to do that, the mapper needs to know if a particular join key exists on the left hand side.</p>

<p>An easy way to accomplish this is to put the smaller dataset into the <code>DistributedCache</code> and then load all the join keys into a <code>HashSet</code> that the mapper can do a lookup against.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="k">for</span> <span class="o">(</span><span class="n">FileStatus</span> <span class="n">status</span> <span class="o">:</span> <span class="n">fileSystem</span><span class="o">.</span><span class="na">globStatus</span><span class="o">(</span><span class="n">theSmallSideOfTheJoin</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">DistributedCache</span><span class="o">.</span><span class="na">addCacheFile</span><span class="o">(</span><span class="n">status</span><span class="o">.</span><span class="na">getPath</span><span class="o">().</span><span class="na">toUri</span><span class="o">(),</span> <span class="n">job</span><span class="o">.</span><span class="na">getConfiguration</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">protected</span> <span class="kt">void</span> <span class="nf">setup</span><span class="o">(</span><span class="n">Mapper</span><span class="o">.</span><span class="na">Context</span> <span class="n">context</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">buildJoinKeyHashMap</span><span class="o">(</span><span class="n">context</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">protected</span> <span class="kt">void</span> <span class="nf">map</span><span class="o">(</span><span class="n">LongWritable</span> <span class="n">key</span><span class="o">,</span> <span class="n">Text</span> <span class="n">value</span><span class="o">,</span> <span class="n">Context</span> <span class="n">context</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">...</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">if</span> <span class="o">(!</span><span class="n">joinKeys</span><span class="o">.</span><span class="na">contains</span><span class="o">(</span><span class="n">joinKey</span><span class="o">))</span>
</span><span class='line'>      <span class="k">return</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="o">...</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">context</span><span class="o">.</span><span class="na">write</span><span class="o">(</span><span class="n">outKey</span><span class="o">,</span> <span class="n">outVal</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>This totally works, but consumes enough memory that I was occassionally getting <code>java.lang.OutOfMemoryError: Java heap space</code> from the mappers. Enter the <a href="http://en.wikipedia.org/wiki/Bloom_filter">Bloom filter</a>.</p>

<blockquote><p>A Bloom filter is a space-efficient probabilistic data structure that is used to test whether an element is a member of a set. False positive matches are possible, but false negatives are not. Elements can be added to the set, but not removed. The more elements that are added to the set, the larger the probability of false positives. -Wikipedia</p></blockquote>

<p>I hadn&rsquo;t heard of a Bloom filter before taking <a href="https://www.coursera.org/course/algo">Algorithms: Design and Analysis, Part 1</a>. If not for the course, I&rsquo;m pretty sure I would have skimmed over the innocuous reference while pilfering around the hadoop <a href="http://hadoop.apache.org/docs/current/api/org/apache/hadoop/util/bloom/BloomFilter.html">documentation</a>. Fortunately, recent exposure made the term jump out at me and I quickly recognized it was exactly what I was looking for.</p>

<p>When I took the course, I thought the Bloom filter was an interesting idea that I wasn&rsquo;t likely to use anytime soon because I haven&rsquo;t needed one yet and I&rsquo;ve been programming professionally for more than a few years. But you don&rsquo;t know what you don&rsquo;t know, right? It&rsquo;s like thinking about buying a car you didn&rsquo;t notice before and now seeing it everywhere.</p>

<h3>Configuration</h3>

<p>The documentation is thin, with little more than variable names to glean meaning from.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="nf">BloomFilter</span><span class="o">(</span><span class="kt">int</span> <span class="n">vectorSize</span><span class="o">,</span>
</span><span class='line'>                   <span class="kt">int</span> <span class="n">nbHash</span><span class="o">,</span>
</span><span class='line'>                   <span class="kt">int</span> <span class="n">hashType</span><span class="o">)</span>
</span></code></pre></td></tr></table></div></figure>


<ul>
<li><code>vectorSize</code> - The vector size of this filter.</li>
<li><code>nbHash</code> - The number of hash function to consider.</li>
<li><code>hashType</code> - type of the hashing function (see Hash).</li>
</ul>


<p>I know what you&rsquo;re thinking. What could be more helpful than <em>The vector size of this filter</em> as a description for <code>vectorSize</code>? Well, the basic idea is there&rsquo;s a trade-off between space, speed and probability of a false positive. Here&rsquo;s how I think about it:</p>

<ul>
<li><code>vectorSize</code> - The amount of memory used to store hash keys. Larger values are less likey to yield false positives. If the value is too large, you might as well use a <code>HashSet</code>.</li>
<li><code>nbHash</code> - The number of times to hash the key. Larger numbers are less likely to yeild false positives at the expense of additional computation effort. Expect deminishing returns on larger values.</li>
<li><code>hashType</code> - type of the hashing function (see Hash). The Hash documentation was reasonable so I&rsquo;m not going to add anything.</li>
</ul>


<p>I used trial and error to figure out numbers that were good for my constraints.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">BloomFilterTests</span> <span class="o">{</span>
</span><span class='line'>    <span class="kd">private</span> <span class="kd">static</span> <span class="n">BloomFilter</span> <span class="n">bloomFilter</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">private</span> <span class="kd">static</span> <span class="n">String</span> <span class="n">knownKey</span> <span class="o">=</span> <span class="n">newGuid</span><span class="o">();</span>
</span><span class='line'>    <span class="kd">private</span> <span class="kd">static</span> <span class="kt">int</span> <span class="n">numberOfKeys</span> <span class="o">=</span> <span class="mi">500000</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@BeforeClass</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">before</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">bloomFilter</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BloomFilter</span><span class="o">(</span><span class="n">numberOfKeys</span> <span class="o">*</span> <span class="mi">20</span><span class="o">,</span> <span class="mi">8</span><span class="o">,</span> <span class="n">Hash</span><span class="o">.</span><span class="na">MURMUR_HASH</span><span class="o">);</span>
</span><span class='line'>        <span class="n">bloomFilter</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">newKey</span><span class="o">(</span><span class="n">knownKey</span><span class="o">));</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">numberOfKeys</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span>
</span><span class='line'>            <span class="n">bloomFilter</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">newKey</span><span class="o">(</span><span class="n">newGuid</span><span class="o">()));</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Test</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">should_contain_known_key</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">assertThat</span><span class="o">(</span><span class="n">hasKey</span><span class="o">(</span><span class="n">knownKey</span><span class="o">),</span> <span class="n">is</span><span class="o">(</span><span class="kc">true</span><span class="o">));</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Test</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">false_positive_probability_should_be_low</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="kt">int</span> <span class="n">count</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
</span><span class='line'>        <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">numberOfKeys</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">hasKey</span><span class="o">(</span><span class="n">newGuid</span><span class="o">()))</span>
</span><span class='line'>                <span class="n">count</span><span class="o">++;</span>
</span><span class='line'>
</span><span class='line'>        <span class="kt">int</span> <span class="n">onePercent</span> <span class="o">=</span> <span class="o">(</span><span class="kt">int</span><span class="o">)</span> <span class="o">(</span><span class="n">numberOfKeys</span> <span class="o">*</span> <span class="o">.</span><span class="mi">01</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">assertThat</span><span class="o">(</span><span class="n">count</span><span class="o">,</span> <span class="n">is</span><span class="o">(</span><span class="n">lessThan</span><span class="o">(</span><span class="n">onePercent</span><span class="o">)));</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="kd">static</span> <span class="n">String</span> <span class="nf">newGuid</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="n">UUID</span><span class="o">.</span><span class="na">randomUUID</span><span class="o">().</span><span class="na">toString</span><span class="o">();</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="kd">static</span> <span class="n">Key</span> <span class="nf">newKey</span><span class="o">(</span><span class="n">String</span> <span class="n">key</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="k">new</span> <span class="nf">Key</span><span class="o">(</span><span class="n">key</span><span class="o">.</span><span class="na">getBytes</span><span class="o">());</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="kt">boolean</span> <span class="nf">hasKey</span><span class="o">(</span><span class="n">String</span> <span class="n">key</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="n">bloomFilter</span><span class="o">.</span><span class="na">membershipTest</span><span class="o">(</span><span class="n">newKey</span><span class="o">(</span><span class="n">key</span><span class="o">));</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>When you have your numbers worked out, simply swap out the <code>HashMap</code> with the <code>BloomFilter</code> and then blog about it.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Extracting Root Domain From a Url]]></title>
    <link href="http://www.mikevalenty.com/extracting-root-domain-from-a-url/"/>
    <updated>2013-10-06T17:05:00-07:00</updated>
    <id>http://www.mikevalenty.com/extracting-root-domain-from-a-url</id>
    <content type="html"><![CDATA[<p>Given a url like <code>http://www.google.com/?q=tld+uk</code>, extract the <em>root domain</em>. In this case, it would be <code>google.com</code>. Sounds easy, right? Well it is, but <code>http://www.google.com.br/</code> is also legit. Okay, so recursion to the rescue!</p>

<p>Not so fast&hellip;</p>

<pre>
.ac.uk
.co.uk
.gov.uk
.parliament.uk
.police.uk
...
.metro.tokyo.jp
.city.(cityname).(prefecturename).jp
...
</pre>


<blockquote><p><a href="http://en.wikipedia.org/wiki/.uk">http://en.wikipedia.org/wiki/.uk</a></br><a href="http://en.wikipedia.org/wiki/.jp">http://en.wikipedia.org/wiki/.jp</a></p></blockquote>

<p>Doh! Surely <a href="http://en.wikipedia.org/wiki/Parliament_(band)">George Clinton</a> is not happy about this and neither am I because it means I&rsquo;m stuck doing a lookup against a list of arbitrary domains.</p>

<p>Using <code>java.net.URI</code> takes care of extracting the host, so the interesting part is parsing the host into a list of chunks that decrease in number of segments.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="n">test</span><span class="o">(</span><span class="s">&quot;should split host into chunks of decreasing parts&quot;</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">chunks</span> <span class="k">=</span> <span class="n">splitIntoChunks</span><span class="o">(</span><span class="s">&quot;www.google.com.br&quot;</span><span class="o">)</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">chunks</span><span class="o">.</span><span class="n">toList</span> <span class="n">should</span> <span class="n">equal</span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="s">&quot;www.google.com.br&quot;</span><span class="o">,</span> <span class="s">&quot;google.com.br&quot;</span><span class="o">,</span> <span class="s">&quot;com.br&quot;</span><span class="o">,</span> <span class="s">&quot;br&quot;</span><span class="o">))</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>An implementation of <code>splitIntoChunks</code> isn&rsquo;t terribly exciting, but probably a good interview question. How about an implementation that doesn&rsquo;t mutate state? Sounds fun, but why make this more difficult? It&rsquo;s not because I want to run <em>this</em> bit of code on mutliple cores or distributed across machines, but because it challenges me to change the way I think about simple problems so that solving more complicated problems using functional idioms feels more natural. After all, when something is painful, you should do it more often. You know, like push ups and deployments.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='scala'><span class='line'><span class="k">def</span> <span class="n">splitIntoChunks</span><span class="o">(</span><span class="n">host</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span> <span class="k">=</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">val</span> <span class="n">parts</span> <span class="k">=</span> <span class="n">host</span><span class="o">.</span><span class="n">split</span><span class="o">(</span><span class="sc">&#39;.&#39;</span><span class="o">).</span><span class="n">toList</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">parts</span><span class="o">.</span><span class="n">dropRight</span><span class="o">(</span><span class="mi">1</span><span class="o">).</span><span class="n">scanRight</span><span class="o">(</span><span class="n">parts</span><span class="o">.</span><span class="n">last</span><span class="o">)</span> <span class="o">{(</span><span class="n">acc</span><span class="o">,</span> <span class="n">p</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="n">s</span><span class="s">&quot;$acc.$p&quot;</span><span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Scala ftw.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Appreciating Algorithm Complexity]]></title>
    <link href="http://www.mikevalenty.com/appreciating-algorithm-complexity/"/>
    <updated>2013-10-05T12:52:00-07:00</updated>
    <id>http://www.mikevalenty.com/appreciating-algorithm-complexity</id>
    <content type="html"><![CDATA[<p><a href="https://www.coursera.org/course/algo">Algorithms: Design and Analysis, Part 1</a> is a free online course from Standford offered through <a href="https://www.coursera.org/">Coursera.org</a>. An assignment that stuck with me was implementing an algorithm for counting inversions. Counting inversions is a way to quantify similarity of two ordered lists. The canonical example described in the lectures was comparing lists of favorite movies.</p>

<p>I banged out a naive implementation using nested loops that I could use for comparison to make sure I was implementing the real algorithm correctly.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">private</span> <span class="kt">long</span> <span class="nf">countQuadratic</span><span class="o">(</span><span class="kt">int</span><span class="o">[]</span> <span class="n">a</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="kt">long</span> <span class="n">count</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
</span><span class='line'>    <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">a</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span>
</span><span class='line'>        <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="n">i</span><span class="o">;</span> <span class="n">j</span> <span class="o">&lt;</span> <span class="n">a</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">a</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">&gt;</span> <span class="n">a</span><span class="o">[</span><span class="n">j</span><span class="o">])</span>
</span><span class='line'>                <span class="n">count</span><span class="o">++;</span>
</span><span class='line'>    <span class="k">return</span> <span class="n">count</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The algorithm described in lecture is a divide and conquer algorithm based on a variation of <a href="http://en.wikipedia.org/wiki/Merge_sort">merge sort</a>, and as you might expect from its lineage, runs in <code>O(nlog(n))</code> time.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">private</span> <span class="kt">long</span> <span class="nf">countLinearithmic</span><span class="o">(</span><span class="kt">int</span><span class="o">[]</span> <span class="n">a</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// REDACTED</span>
</span><span class='line'>
</span><span class='line'>    <span class="kt">long</span> <span class="n">countLeft</span> <span class="o">=</span> <span class="n">countLinearithmic</span><span class="o">(</span><span class="n">left</span><span class="o">);</span>
</span><span class='line'>    <span class="kt">long</span> <span class="n">countRight</span> <span class="o">=</span> <span class="n">countLinearithmic</span><span class="o">(</span><span class="n">right</span><span class="o">);</span>
</span><span class='line'>    <span class="kt">long</span> <span class="n">countSplit</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
</span><span class='line'>    <span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
</span><span class='line'>    <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">k</span> <span class="o">&lt;</span> <span class="n">a</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">k</span><span class="o">++)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="c1">// REDACTED</span>
</span><span class='line'>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="n">countLeft</span> <span class="o">+</span> <span class="n">countRight</span> <span class="o">+</span> <span class="n">countSplit</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><em>* The guts of the implementation are not shown per the <a href="https://www.coursera.org/about/honorcode">Coursera honor code</a>.</em></p>

<p>The assignment was to run this algorithm on a list of 100,000 integers and report the number of inversions. I ran both implementations as a sanity check.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">should_count_inversions_in_text_file</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kt">int</span><span class="o">[]</span> <span class="n">a</span> <span class="o">=</span> <span class="n">FileUtil</span><span class="o">.</span><span class="na">parseInts</span><span class="o">(</span><span class="s">&quot;Inversions.txt&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="n">assertThat</span><span class="o">(</span><span class="n">a</span><span class="o">.</span><span class="na">length</span><span class="o">,</span> <span class="n">is</span><span class="o">(</span><span class="mi">100000</span><span class="o">));</span>
</span><span class='line'>
</span><span class='line'>    <span class="kt">long</span> <span class="n">start1</span> <span class="o">=</span> <span class="n">System</span><span class="o">.</span><span class="na">currentTimeMillis</span><span class="o">();</span>
</span><span class='line'>    <span class="kt">long</span> <span class="n">count1</span> <span class="o">=</span> <span class="n">countQuadratic</span><span class="o">(</span><span class="n">a</span><span class="o">);</span> <span class="c1">// O(n^2)</span>
</span><span class='line'>    <span class="kt">long</span> <span class="n">duration1</span> <span class="o">=</span> <span class="n">start1</span> <span class="o">-</span> <span class="n">System</span><span class="o">.</span><span class="na">currentTimeMillis</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">println</span><span class="o">(</span><span class="s">&quot;countQuadratic: &quot;</span> <span class="o">+</span> <span class="n">duration1</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="kt">long</span> <span class="n">start2</span> <span class="o">=</span> <span class="n">System</span><span class="o">.</span><span class="na">currentTimeMillis</span><span class="o">();</span>
</span><span class='line'>    <span class="kt">long</span> <span class="n">count2</span> <span class="o">=</span> <span class="n">countLinearithmic</span><span class="o">(</span><span class="n">a</span><span class="o">);</span> <span class="c1">// O(nlog(n))</span>
</span><span class='line'>    <span class="kt">long</span> <span class="n">duration2</span> <span class="o">=</span> <span class="n">start2</span> <span class="o">-</span> <span class="n">System</span><span class="o">.</span><span class="na">currentTimeMillis</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">println</span><span class="o">(</span><span class="s">&quot;countLinearithmic: &quot;</span> <span class="o">+</span> <span class="n">duration2</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">assertThat</span><span class="o">(</span><span class="n">count1</span><span class="o">,</span> <span class="n">is</span><span class="o">(</span><span class="n">equalTo</span><span class="o">(</span><span class="n">count2</span><span class="o">)));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p> It&rsquo;s one thing to crunch numbers on a calulator or plot graphs to gain an intuition for algorithm complexity, but it&rsquo;s quite a bit more meaningful to wait for 15 seconds while a 2.7GHz quad-core Intel Core i7 grinds through ~5 Billion comparisions <code>O(n^2)</code> versus a mere 140 ms to zip through 1.6 Million comparisons using an <code>O(nlog(n))</code> implementation.</p>

<blockquote><p>Yeah, science!</p></blockquote>

<iframe width="560" height="315" src="//www.youtube.com/embed/eQR1r1KTjaE" frameborder="0" allowfullscreen></iframe>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Configuring Decorators With Google Guice]]></title>
    <link href="http://www.mikevalenty.com/configuring-decorators-with-google-guice/"/>
    <updated>2012-02-20T07:11:00-08:00</updated>
    <id>http://www.mikevalenty.com/configuring-decorators-with-google-guice</id>
    <content type="html"><![CDATA[<p>You have a few options and each have their trade-offs. The one I find least annoying requires using a binding annotation. Since I’m stuck using annotations with Guice anyway, using one more to facilitate a decorator seems like an acceptable concession. Before I go on though, I have to take a moment. My beef isn’t about verbose configuration or annotations, it’s that once again the documentation gets it all wrong and sends the impressionable reader down a misguided path. Let’s take a look at this excerpt from the Guice documentation for binding annotations:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">RealBillingService</span> <span class="kd">implements</span> <span class="n">BillingService</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Inject</span>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">RealBillingService</span><span class="o">(</span><span class="nd">@PayPal</span> <span class="n">CreditCardProcessor</span> <span class="n">processor</span><span class="o">,</span> <span class="o">...)</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">...</span>
</span><span class='line'>  <span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>This bit of innocuous code encourages the reader to squander the power of dependency inversion and reduce it to a clunky tool that makes unit testing a little bit easier. That sounds harsh, so let’s start by discussing what Guice is and the problem it solves.</p>

<p>Guice and the like are referred to as IoC containers. That’s Inversion of Control. It’s a pretty general principle and when applied to object oriented programming, it manifests itself in the form of a technique called <em>Dependency Inversion</em>. In terms of the <code>BillingService</code> example, it means the code depends on a <code>CreditCardProcessor</code> abstraction rather than new‘ing something specific like a <code>PayPalCreditCardProcessor</code>. Perhaps depends is an overloaded term here. With or without the new keyword, there is a dependency. In one case, a higher level module is responsible for deciding what implementation to use, and in the other case, the class itself decides that it’s using a <code>PayPalCreditCardProcessor</code>, period.</p>

<p>Writing all your classes to declare their dependencies leaves you with the tedious task of building up complex object graphs before you can actually use your object. This is where Guice comes in. It’s a tool to simplify the havoc wreaked by inverting your dependencies and it’s inevitable when guided by a few principles like DRY (Don’t Repeat Yourself). If you don’t believe me, go ahead a see for yourself. Write some truly SOLID code and you’ll end up writing an IoC container in the process.</p>

<p>So now that we’ve covered what Guice is and the problem it solves, we are ready to talk about what’s wrong with <code>@PayPal</code>. Specifying the concrete class you expect with an annotation is pretty much the same as just declaring the dependency explicitly. Sure, you get a few points for using an interface and injecting the object, but it’s really just going through the motions while entirely missing the point. It would be like the Karate Kid going into auto detailing after learning wax-on, wax-off.</p>

<p>Abstractions create seams in your code. It’s how you add new behavior as the application evolves and it’s the key to managing complexity. Since we’re looking at a billing example, let’s throw out a few requirements that could pop up. How about some protection against running the same transaction twice in a short time period. How about checking a blacklist of credit cards or customers. Or maybe you need a card number that always fails in a particular way so QA can test the sad path. Or maybe your company works with a few payment gateways and wants to choose the least cost option based on the charge amount or card type. In this little snippet of code, we’ve got 2 seams we can use to work in this behavior. We’ve got the <code>BillingService</code> and <code>CreditCardProcesor</code>.</p>

<p>Oh, wait a minute we’re declaring that we need the <code>PayPalCreditCardProcessor</code> with that annotation so now our code is rigid and we can’t inject additional behavior by wrapping it in a <code>DoubleChargeCreditCardProcessor</code>, open-closed style. That’s the ‘O’ in SOLID. So you’re probably thinking, why can’t you just change the annotation from <code>@PayPal</code> to <code>@DoubleCharge</code>? Let’s dive a little deeper into this example to find out:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">DoubleChargeCreditCardProcessor</span> <span class="kd">implements</span> <span class="n">CreditCardProcessor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Inject</span>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">DoubleChargeCreditCardProcessor</span><span class="o">(</span><span class="n">CreditCardProcessor</span> <span class="n">processor</span><span class="o">,</span> <span class="o">...)</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">...</span>
</span><span class='line'>  <span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>I’m not going to rant about how extends is evil and that you’re better off with a decorator because <a href="http://www.mikevalenty.com/inheritance-is-evil-the-story-of-the-epic-fail-of-dataannotationsmodelbinder/">I’ve already done that</a>, and this article is about how to wire up a decorator with Guice. So the challenge here is how to configure the container to supply the correct credit card processor as the first dependency of our double charge processor which itself implements <code>CreditCardProcessor</code>. Looking at the Guice documentation, you would likely think the answer is to do this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">RealBillingService</span> <span class="kd">implements</span> <span class="n">BillingService</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Inject</span>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">RealBillingService</span><span class="o">(</span><span class="nd">@DoubleCharge</span> <span class="n">CreditCardProcessor</span> <span class="n">processor</span><span class="o">,</span> <span class="o">...)</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">...</span>
</span><span class='line'>  <span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">DoubleChargeCreditCardProcessor</span> <span class="kd">implements</span> <span class="n">CreditCardProcessor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Inject</span>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">DoubleChargeCreditCardProcessor</span><span class="o">(</span><span class="nd">@PayPal</span> <span class="n">CreditCardProcessor</span> <span class="n">processor</span><span class="o">,</span> <span class="o">...)</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">...</span>
</span><span class='line'>  <span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>That’s wrong though. The <code>CreditCardProcessor</code> isn’t a <em>thing</em>, it’s a <em>seam</em> and it’s where you put additional behavior like preventing duplicate charges in a short time period. If you look at the decorator, you’ll notice that it has nothing to do with PayPal. That’s because it’s a business rule and shouldn’t be mixed with integration code. Our business rule code and the PayPal integration code will likely live in different packages and the <code>CreditCardProcessor</code> abstraction could get assembled differently for any number of reasons. Maybe your application supports <a href="http://www.mikevalenty.com/bolt-on-multi-tenancy-in-asp-net-mvc-with-unity-and-nhibernate-part-ii-commingled-data/">multi-tenancy</a> and each tenant can use a different payment gateway. We can’t reuse our double charge business rule if it’s hard-coded to wrap a PayPal processor, and that’s a problem.</p>

<p>While I don’t particularly like using annotations for this sort of thing, it’s not the root cause. As a mechanic, it works just fine and can help us accomplish our task. The problem is that the documentation is subtly wrong and encourages mis-use of this feature. The better way to use binding annotations and not undermine the point of injecting your dependencies is like so:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">DoubleChargeCreditCardProcessor</span> <span class="kd">implements</span> <span class="n">CreditCardProcessor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">BASE</span> <span class="o">=</span> <span class="s">&quot;DoubleChargeCreditCardProcessor.base&quot;</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">DoubleChargeCreditCardProcessor</span><span class="o">(</span><span class="nd">@Named</span><span class="o">(</span><span class="n">BASE</span><span class="o">)</span> <span class="n">CreditCardProcessor</span> <span class="n">processor</span><span class="o">,</span> <span class="o">...)</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">...</span>
</span><span class='line'>  <span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">ConfigureCreditCardProcessor</span> <span class="kd">extends</span> <span class="n">AbstractModule</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">protected</span> <span class="kt">void</span> <span class="nf">configure</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">bind</span><span class="o">(</span><span class="n">CreditCardProcessor</span><span class="o">.</span><span class="na">class</span><span class="o">).</span><span class="na">to</span><span class="o">(</span><span class="n">DoubleChargeCreditCardProcessor</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">bind</span><span class="o">(</span><span class="n">CreditCardProcessor</span><span class="o">.</span><span class="na">class</span><span class="o">)</span>
</span><span class='line'>      <span class="o">.</span><span class="na">annotatedWith</span><span class="o">(</span><span class="n">Names</span><span class="o">.</span><span class="na">named</span><span class="o">(</span><span class="n">DoubleChargeCreditCardProcessor</span><span class="o">.</span><span class="na">BASE</span><span class="o">))</span>
</span><span class='line'>      <span class="o">.</span><span class="na">to</span><span class="o">(</span><span class="n">PayPayCreditCardProcessor</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The difference is subtle, but the devil is in the details. In this last example, the <code>DoubleChargeCreditCardProcessor</code> doesn’t know or care what implementation it’s decorating. It simply declares a name for it’s dependency so it can be referenced unambiguously in a configuration module. This moves the configuration logic to… well, configuration code. Now you can see that the code is once again flexible and you can easily imagine more sophisticated configuration logic that could consider tenant settings or environment variables in selecting the proper combination of credit card processors to assemble.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Bolt-on Multi-Tenancy in ASP.NET MVC With Unity and NHibernate: Part II – Commingled Data]]></title>
    <link href="http://www.mikevalenty.com/bolt-on-multi-tenancy-in-asp-net-mvc-with-unity-and-nhibernate-part-ii-commingled-data/"/>
    <updated>2011-06-18T11:08:00-07:00</updated>
    <id>http://www.mikevalenty.com/bolt-on-multi-tenancy-in-asp-net-mvc-with-unity-and-nhibernate-part-ii-commingled-data</id>
    <content type="html"><![CDATA[<p>Last time I went over going from separate web applications per tenant to a shared web application for all tenants, but each tenant still had its own database. Now we’re going to take the next step and let multiple tenants share the same database. After we add <code>tenant_id</code> to most of the tables in our database we’ll need the application to take care of a few things. First, we need to apply a where clause to all queries to ensure that each tenant sees only their data. This is pretty painless with NHibernate, we just have to define a parameterized filter:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'><span class="nt">&lt;hibernate-mapping</span> <span class="na">xmlns=</span><span class="s">&quot;urn:nhibernate-mapping-2.2&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>
</span><span class='line'>  <span class="nt">&lt;filter-def</span> <span class="na">name=</span><span class="s">&quot;tenant&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;filter-param</span> <span class="na">name=</span><span class="s">&quot;id&quot;</span> <span class="na">type=</span><span class="s">&quot;System.Int32&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>  <span class="nt">&lt;/filter-def&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="nt">&lt;/hibernate-mapping&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>And then apply it to each entity:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'><span class="nt">&lt;class</span> <span class="na">name=</span><span class="s">&quot;User&quot;</span> <span class="na">table=</span><span class="s">&quot;[user]&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>
</span><span class='line'>  <span class="nt">&lt;id</span> <span class="na">name=</span><span class="s">&quot;Id&quot;</span> <span class="na">column=</span><span class="s">&quot;user_id&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;generator</span> <span class="na">class=</span><span class="s">&quot;identity&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>  <span class="nt">&lt;/id&gt;</span>
</span><span class='line'>
</span><span class='line'>  <span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">&quot;Username&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>  <span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">&quot;Email&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>
</span><span class='line'>  <span class="nt">&lt;filter</span> <span class="na">name=</span><span class="s">&quot;tenant&quot;</span> <span class="na">condition=</span><span class="s">&quot;tenant_id = :id&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="nt">&lt;/class&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>The last step is to set the value of the filter at runtime. This is done on the <code>ISession</code> like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">ISession</span><span class="p">&gt;(</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">PerRequestLifetimeManager</span><span class="p">(),</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">InjectionFactory</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="kt">var</span> <span class="n">session</span> <span class="p">=</span> <span class="n">c</span><span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">ISessionFactory</span><span class="p">&gt;().</span><span class="n">OpenSession</span><span class="p">();</span>
</span><span class='line'>            <span class="n">session</span><span class="p">.</span><span class="n">EnableFilter</span><span class="p">(</span><span class="s">&quot;tenant&quot;</span><span class="p">).</span><span class="n">SetParameter</span><span class="p">(</span><span class="s">&quot;id&quot;</span><span class="p">,</span> <span class="n">c</span><span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">Tenant</span><span class="p">&gt;().</span><span class="n">Id</span><span class="p">);</span>
</span><span class='line'>            <span class="k">return</span> <span class="n">session</span><span class="p">;</span>
</span><span class='line'>        <span class="p">})</span>
</span><span class='line'>    <span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>The current tenant comes from <code>c.Resolve&lt;Tenant&gt;()</code>. In order for that to work, you have to tell Unity how to find the current tenant. In ASP.NET MVC, we can look at the host header on the request and find our tenant that way. We could just as easily use another strategy though. Maybe if this were a WCF service, we could use an authentication header to establish the current tenant context. You could build out some interfaces and strategies around establishing the current tenant context, however for this article I’ll just bang it out.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">Tenant</span><span class="p">&gt;(</span><span class="k">new</span> <span class="n">InjectionFactory</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">repository</span> <span class="p">=</span> <span class="n">c</span><span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">ITenantRepository</span><span class="p">&gt;();</span>
</span><span class='line'>
</span><span class='line'>        <span class="kt">var</span> <span class="n">context</span> <span class="p">=</span> <span class="n">c</span><span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">HttpContextBase</span><span class="p">&gt;();</span>
</span><span class='line'>
</span><span class='line'>        <span class="kt">var</span> <span class="n">host</span> <span class="p">=</span> <span class="n">context</span><span class="p">.</span><span class="n">Request</span><span class="p">.</span><span class="n">Headers</span><span class="p">[</span><span class="s">&quot;Host&quot;</span><span class="p">]</span> <span class="p">??</span> <span class="n">context</span><span class="p">.</span><span class="n">Request</span><span class="p">.</span><span class="n">Url</span><span class="p">.</span><span class="n">Host</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">repository</span><span class="p">.</span><span class="n">FindByHost</span><span class="p">(</span><span class="n">host</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}));</span>
</span></code></pre></td></tr></table></div></figure>


<p>Second, we have to set the <code>tenant_id</code> when new entities are saved. This is a bit more complicated with NHibernate and requires a bit of a concession in that we have to add a field to the entity in order for NHibernate to know how to persist the value. I’m using a private nullable int for this.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">User</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="kt">int?</span> <span class="n">tenantId</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">virtual</span> <span class="kt">int</span> <span class="n">Id</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">virtual</span> <span class="kt">string</span> <span class="n">Username</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">virtual</span> <span class="kt">string</span> <span class="n">Email</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>It’s private because I don’t want the business logic to deal with it and it’s nullable because my tenant table is in a separate database which means I can’t lean on the data model to enforce referential integrity. That’s a problem because the default value for an integer is zero which could be happily saved by the database. By making it nullable I can be sure the database will blow up if the <code>tenant_id</code> is not set.</p>

<p>So, back to the issue at hand. The <code>tenant_id</code> needs to be set when the entity is saved. For this, I’m using an interceptor and setting the value in the <code>OnSave</code> method:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">MultiTenantInterceptor</span> <span class="p">:</span> <span class="n">EmptyInterceptor</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">Func</span><span class="p">&lt;</span><span class="n">Tenant</span><span class="p">&gt;</span> <span class="n">tenant</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="nf">MultiTenantInterceptor</span><span class="p">(</span><span class="n">Func</span><span class="p">&lt;</span><span class="n">Tenant</span><span class="p">&gt;</span> <span class="n">tenant</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">tenant</span> <span class="p">=</span> <span class="n">tenant</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">override</span> <span class="kt">bool</span> <span class="nf">OnSave</span><span class="p">(</span><span class="kt">object</span> <span class="n">entity</span><span class="p">...</span> <span class="kt">object</span><span class="p">[]</span> <span class="n">state</span><span class="p">,</span> <span class="kt">string</span><span class="p">[]</span> <span class="n">propertyNames</span><span class="p">...)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">index</span> <span class="p">=</span> <span class="n">Array</span><span class="p">.</span><span class="n">IndexOf</span><span class="p">(</span><span class="n">propertyNames</span><span class="p">,</span> <span class="s">&quot;tenantId&quot;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">index</span> <span class="p">==</span> <span class="p">-</span><span class="m">1</span><span class="p">)</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">false</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="kt">var</span> <span class="n">tenantId</span> <span class="p">=</span> <span class="n">tenant</span><span class="p">().</span><span class="n">Id</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">state</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="p">=</span> <span class="n">tenantId</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">entity</span>
</span><span class='line'>            <span class="p">.</span><span class="n">GetType</span><span class="p">()</span>
</span><span class='line'>            <span class="p">.</span><span class="n">GetField</span><span class="p">(</span><span class="s">&quot;tenantId&quot;</span><span class="p">,</span> <span class="n">BindingFlags</span><span class="p">.</span><span class="n">Instance</span> <span class="p">|</span> <span class="n">BindingFlags</span><span class="p">.</span><span class="n">NonPublic</span><span class="p">)</span>
</span><span class='line'>            <span class="p">.</span><span class="n">SetValue</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">tenantId</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="k">false</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>This <code>IInterceptor</code> mechanism is a little wonky. If you change any data, you have to do it in both the entity instance and the state array that NHibernate uses to hydrate entities. It’s not a big deal, it’s just one of those things you have to accept like the fact that Apple and Google are tracking your every move via your smart phone. Oh, and the interceptor gets wired up like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">ISessionFactory</span><span class="p">&gt;(</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">ContainerControlledLifetimeManager</span><span class="p">(),</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">InjectionFactory</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="n">NHibernate</span><span class="p">.</span><span class="n">Cfg</span><span class="p">.</span><span class="n">Configuration</span><span class="p">()</span>
</span><span class='line'>                <span class="p">.</span><span class="n">Configure</span><span class="p">()</span>
</span><span class='line'>                <span class="p">.</span><span class="n">SetInterceptor</span><span class="p">(</span><span class="k">new</span> <span class="n">MultiTenantInterceptor</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="n">c</span><span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">Tenant</span><span class="p">&gt;()))</span>
</span><span class='line'>                <span class="p">.</span><span class="n">BuildSessionFactory</span><span class="p">();</span>
</span><span class='line'>        <span class="p">})</span>
</span><span class='line'>    <span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>We’re almost done. There is one more case that needs to be handled. When NHibernate loads an entity by its primary key, it doesn’t run through the query engine which means the tenant filter isn’t applied. Fortunately, we can take care of this in the interceptor:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">MultiTenantInterceptor</span> <span class="p">:</span> <span class="n">EmptyInterceptor</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="p">...</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">override</span> <span class="kt">bool</span> <span class="nf">OnLoad</span><span class="p">(</span><span class="kt">object</span> <span class="n">entity</span><span class="p">...</span> <span class="kt">object</span><span class="p">[]</span> <span class="n">state</span><span class="p">,</span> <span class="kt">string</span><span class="p">[]</span> <span class="n">propertyNames</span><span class="p">...)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">index</span> <span class="p">=</span> <span class="n">Array</span><span class="p">.</span><span class="n">IndexOf</span><span class="p">(</span><span class="n">propertyNames</span><span class="p">,</span> <span class="s">&quot;tenantId&quot;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">index</span> <span class="p">==</span> <span class="p">-</span><span class="m">1</span><span class="p">)</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">false</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="kt">var</span> <span class="n">entityTenantId</span> <span class="p">=</span> <span class="n">Convert</span><span class="p">.</span><span class="n">ToInt32</span><span class="p">(</span><span class="n">state</span><span class="p">[</span><span class="n">index</span><span class="p">]);</span>
</span><span class='line'>
</span><span class='line'>        <span class="kt">var</span> <span class="n">currentTenantId</span> <span class="p">=</span> <span class="n">tenant</span><span class="p">().</span><span class="n">Id</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">entityTenantId</span> <span class="p">!=</span> <span class="n">currentTenantId</span><span class="p">)</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">throw</span> <span class="k">new</span> <span class="nf">AuthorizationException</span><span class="p">(</span><span class="s">&quot;Permission denied to {0}&quot;</span><span class="p">,</span> <span class="n">entity</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="k">false</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>That’s it. Have fun and happy commingling.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Bolt-on Multi-Tenancy in ASP.NET MVC With Unity and NHibernate]]></title>
    <link href="http://www.mikevalenty.com/bolt-on-multi-tenancy-in-asp-net-mvc-with-unity-and-nhibernate/"/>
    <updated>2011-05-14T13:09:00-07:00</updated>
    <id>http://www.mikevalenty.com/bolt-on-multi-tenancy-in-asp-net-mvc-with-unity-and-nhibernate</id>
    <content type="html"><![CDATA[<h3>The Mission:</h3>

<p>Build a web application as though it’s for a single customer (tenant) and add multi-tenancy as a bolt-on feature by writing only new code. There are flavors of multi-tenancy, in this case I want each tenant to have its own database but I want all tenants to share the same web application and figure out who’s who by looking at the host header on the http request.</p>

<h3>The Plan:</h3>

<p>To pull this off, we’re going to have to rely on our SOLID design principles, especially Single Responsibility and Dependency Inversion. We’ll get some help from these frameworks:</p>

<ul>
<li><a href="http://www.asp.net/mvc">ASP.NET MVC</a></li>
<li><a href="http://unity.codeplex.com/">Unity</a></li>
<li><a href="http://nhforge.org/Default.aspx">NHibernate</a></li>
</ul>


<h3>Game on:</h3>

<p>Let’s take a look at a controller that uses NHibernate to talk to the database. I’m not going to get into whether you should talk directly to NHibernate from the controller or go through a service layer or repository because it doesn’t affect how we’re going to add multi-tenancy. The important thing here is that the <code>ISession</code> is injected into the controller, and we aren’t using the service locator pattern to request the <code>ISession</code> from a singleton.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">UserController</span> <span class="p">:</span> <span class="n">Controller</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">ISession</span> <span class="n">session</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="nf">UserController</span><span class="p">(</span><span class="n">ISession</span> <span class="n">session</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">session</span> <span class="p">=</span> <span class="n">session</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="n">ActionResult</span> <span class="nf">Edit</span><span class="p">(</span><span class="kt">int</span> <span class="n">id</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">user</span> <span class="p">=</span> <span class="n">session</span><span class="p">.</span><span class="n">Load</span><span class="p">&lt;</span><span class="n">User</span><span class="p">&gt;(</span><span class="n">id</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="nf">View</span><span class="p">(</span><span class="n">user</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Alright, now it’s time to write some new code and make our web application connect to the correct database based on the host header in the http request. First, we’ll need a database to store a list of tenants along with the connection string for that tenant’s database. Here’s my entity:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">Tenant</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">public</span> <span class="k">virtual</span> <span class="kt">string</span> <span class="n">Name</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">virtual</span> <span class="kt">string</span> <span class="n">Host</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">virtual</span> <span class="kt">string</span> <span class="n">ConnectionString</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>I’ll use the repository pattern here so there is a crisp consumer of the <code>ISession</code> that connects to the lookup database rather than one of the tenant shards. This will be important later when we go to configure Unity.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">NHibernateTenantRepository</span> <span class="p">:</span> <span class="n">ITenantRepository</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">ISession</span> <span class="n">session</span><span class="p">;</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">HttpContextBase</span> <span class="n">context</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="nf">NHibernateTenantRepository</span><span class="p">(</span><span class="n">ISession</span> <span class="n">session</span><span class="p">,</span> <span class="n">HttpContextBase</span> <span class="n">context</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">session</span> <span class="p">=</span> <span class="n">session</span><span class="p">;</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">context</span> <span class="p">=</span> <span class="n">context</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="n">Tenant</span> <span class="n">Current</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">get</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="kt">var</span> <span class="n">host</span> <span class="p">=</span> <span class="n">context</span><span class="p">.</span><span class="n">Request</span><span class="p">.</span><span class="n">Headers</span><span class="p">[</span><span class="s">&quot;Host&quot;</span><span class="p">];</span>
</span><span class='line'>            <span class="k">return</span> <span class="nf">FindByHost</span><span class="p">(</span><span class="n">host</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="n">Tenant</span> <span class="nf">FindByHost</span><span class="p">(</span><span class="kt">string</span> <span class="n">host</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="n">session</span>
</span><span class='line'>            <span class="p">.</span><span class="n">Query</span><span class="p">&lt;</span><span class="n">Tenant</span><span class="p">&gt;()</span>
</span><span class='line'>            <span class="p">.</span><span class="n">SingleOrDefault</span><span class="p">(</span><span class="n">t</span> <span class="p">=&gt;</span> <span class="n">t</span><span class="p">.</span><span class="n">Host</span> <span class="p">==</span> <span class="n">host</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>So now we need a dedicated <code>ISessionFactory</code> for the lookup database and make sure that our <code>NHibernateTenantRepository</code> gets the right <code>ISession</code>. It’s not too bad, we just need to name them in the container so we can refer to them explicitly.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">ISessionFactory</span><span class="p">&gt;(</span>
</span><span class='line'>        <span class="s">&quot;tenant_session_factory&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">ContainerControlledLifetimeManager</span><span class="p">(),</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">InjectionFactory</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span>
</span><span class='line'>            <span class="k">new</span> <span class="n">NHibernate</span><span class="p">.</span><span class="n">Cfg</span><span class="p">.</span><span class="n">Configuration</span><span class="p">().</span><span class="n">Configure</span><span class="p">().</span><span class="n">BuildSessionFactory</span><span class="p">())</span>
</span><span class='line'>    <span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">ISession</span><span class="p">&gt;(</span>
</span><span class='line'>        <span class="s">&quot;tenant_session&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">PerRequestLifetimeManager</span><span class="p">(),</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">InjectionFactory</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span>
</span><span class='line'>            <span class="n">c</span><span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">ISessionFactory</span><span class="p">&gt;(</span><span class="s">&quot;tenant_session_factory&quot;</span><span class="p">).</span><span class="n">OpenSession</span><span class="p">())</span>
</span><span class='line'>    <span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">ITenantRepository</span><span class="p">,</span> <span class="n">NHibernateTenantRepository</span><span class="p">&gt;()</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">NHibernateTenantRepository</span><span class="p">&gt;(</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">InjectionConstructor</span><span class="p">(</span>
</span><span class='line'>            <span class="k">new</span> <span class="n">ResolvedParameter</span><span class="p">&lt;</span><span class="n">ISession</span><span class="p">&gt;(</span><span class="s">&quot;tenant_session&quot;</span><span class="p">),</span>
</span><span class='line'>            <span class="k">new</span> <span class="n">ResolvedParameter</span><span class="p">&lt;</span><span class="n">HttpContextBase</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">)</span>
</span><span class='line'>    <span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>Hopefully that’s about what you were expecting since it’s not really the interesting part. The more interesting part is configuring the <code>ISession</code> that gets injected into the <code>UserController</code> to connect to a different database based on the host header in the http request. The Unity feature we’re going to leverage for this is the <code>LifetimeManager</code>. This is an often overlooked feature of IoC containers.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">ISessionFactory</span><span class="p">&gt;(</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">PerHostLifetimeManager</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="k">new</span> <span class="n">HttpContextWrapper</span><span class="p">(</span><span class="n">HttpContext</span><span class="p">.</span><span class="n">Current</span><span class="p">)),</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">InjectionFactory</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="kt">var</span> <span class="n">connString</span> <span class="p">=</span> <span class="n">c</span>
</span><span class='line'>                <span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">ITenantRepository</span><span class="p">&gt;()</span>
</span><span class='line'>                <span class="p">.</span><span class="n">Current</span>
</span><span class='line'>                <span class="p">.</span><span class="n">ConnectionString</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="n">NHibernate</span><span class="p">.</span><span class="n">Cfg</span><span class="p">.</span><span class="n">Configuration</span><span class="p">()</span>
</span><span class='line'>                <span class="p">.</span><span class="n">Configure</span><span class="p">()</span>
</span><span class='line'>                <span class="p">.</span><span class="n">SetProperty</span><span class="p">(</span><span class="n">NHibernate</span><span class="p">.</span><span class="n">Cfg</span><span class="p">.</span><span class="n">Environment</span><span class="p">.</span><span class="n">ConnectionString</span><span class="p">,</span> <span class="n">connString</span><span class="p">)</span>
</span><span class='line'>                <span class="p">.</span><span class="n">BuildSessionFactory</span><span class="p">();</span>
</span><span class='line'>        <span class="p">}));</span>
</span><span class='line'>
</span><span class='line'><span class="n">Container</span>
</span><span class='line'>    <span class="p">.</span><span class="n">RegisterType</span><span class="p">&lt;</span><span class="n">ISession</span><span class="p">&gt;(</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">PerRequestLifetimeManager</span><span class="p">(),</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">InjectionFactory</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span> <span class="n">c</span><span class="p">.</span><span class="n">Resolve</span><span class="p">&lt;</span><span class="n">ISessionFactory</span><span class="p">&gt;().</span><span class="n">OpenSession</span><span class="p">())</span>
</span><span class='line'>    <span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>Here we’re using a custom <code>PerHostLifetimeManager</code>. This tells Unity to maintain a session factory per host. When Unity runs across a host it doesn’t have a session factory for, it will run the <code>InjectionFactory</code> block to create one using the connection string associated with that tenant.</p>

<p>Since multiple simultaneous requests will be trying to get and set values with the same key, we need to make sure our <code>PerHostLifetimeManager</code> is thread safe. That’s pretty easy since Unity comes with a <code>SynchronizedLifetimeManager</code> base class that takes care of the fact that <code>Dictionary</code> <a href="http://stackoverflow.com/questions/157933/whats-the-best-way-of-implementing-a-thread-safe-dictionary-in-net">isn’t thread safe</a>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">PerHostLifetimeManager</span> <span class="p">:</span> <span class="n">SynchronizedLifetimeManager</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">Func</span><span class="p">&lt;</span><span class="n">HttpContextBase</span><span class="p">&gt;</span> <span class="n">context</span><span class="p">;</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">IDictionary</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">object</span><span class="p">&gt;</span> <span class="n">store</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="nf">PerHostLifetimeManager</span><span class="p">(</span><span class="n">Func</span><span class="p">&lt;</span><span class="n">HttpContextBase</span><span class="p">&gt;</span> <span class="n">context</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">context</span> <span class="p">=</span> <span class="n">context</span><span class="p">;</span>
</span><span class='line'>        <span class="n">store</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Dictionary</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">object</span><span class="p">&gt;();</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">protected</span> <span class="k">override</span> <span class="kt">object</span> <span class="nf">SynchronizedGetValue</span><span class="p">()</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">host</span> <span class="p">=</span> <span class="n">GetHost</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(!</span><span class="n">store</span><span class="p">.</span><span class="n">ContainsKey</span><span class="p">(</span><span class="n">host</span><span class="p">))</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">null</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">store</span><span class="p">[</span><span class="n">host</span><span class="p">];</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">protected</span> <span class="k">override</span> <span class="k">void</span> <span class="nf">SynchronizedSetValue</span><span class="p">(</span><span class="kt">object</span> <span class="n">newValue</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">store</span><span class="p">[</span><span class="n">GetHost</span><span class="p">()]</span> <span class="p">=</span> <span class="n">newValue</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">private</span> <span class="kt">string</span> <span class="nf">GetHost</span><span class="p">()</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="nf">context</span><span class="p">().</span><span class="n">Request</span><span class="p">.</span><span class="n">Headers</span><span class="p">[</span><span class="s">&quot;Host&quot;</span><span class="p">];</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>So what did we accomplish? Well we didn’t touch any of our existing application code. We just wrote new code and through configuration we added multi-tenancy! That’s pretty cool, but was it worth it? Well, the goal in itself isn’t super important, but this exercise can certainly highlight areas of your codebase where you might be violating the single responsibility principle or leaking too many infrastructure concepts into your application logic.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Tamarack: Chain of Responsibility Framework for .NET]]></title>
    <link href="http://www.mikevalenty.com/tamarack-chain-of-responsibility-framework-for-net/"/>
    <updated>2011-04-21T21:39:00-07:00</updated>
    <id>http://www.mikevalenty.com/tamarack-chain-of-responsibility-framework-for-net</id>
    <content type="html"><![CDATA[<p>The Chain of Responsibility is a key building block of extensible software.</p>

<blockquote><p>Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it. – Gang of Four</p></blockquote>

<p>Variations of this pattern are the basis for <a href="http://www.oracle.com/technetwork/java/filters-137243.html">Servlet Filters</a>, <a href="http://learn.iis.net/page.aspx/366/developing-iis-70-modules-and-handlers-with-the-net-framework/">IIS Modules and Handlers</a> and several open source projects I’ve had the opportunity to work with including <a href="https://www.forge.funambol.org/">Sync4J</a>, <a href="http://james.apache.org/">JAMES</a>, <a href="http://logging.apache.org/log4net/">Log4Net</a>, <a href="http://unity.codeplex.com/">Unity</a> and yes, even <a href="http://www.joomla.org/">Joomla</a>. It’s an essential tool in the OO toolbox and key in transforming rigid procedural code into a composable Domain Specific Language.</p>

<p>I’ve blogged about this pattern before so what’s new this time?</p>

<ol>
<li>The next filter in the chain is provided via a delegate parameter rather than a property</li>
<li>The project is <a href="https://github.com/mikevalenty/tamarack">hosted on github</a></li>
<li>There is a <a href="http://nuget.org/List/Search?packageType=Packages&amp;searchCategory=All+Categories&amp;searchTerm=tamarack">NuGet package</a> for it</li>
</ol>


<p><img class="plain" src="http://www.mikevalenty.com/images/posts/pkgmgr31.png"></p>

<p>How does it work?
It’s pretty simple, there is just one interface to implement and it looks like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">interface</span> <span class="n">IFilter</span><span class="p">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">TOut</span><span class="p">&gt;</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">TOut</span> <span class="nf">Execute</span><span class="p">(</span><span class="n">T</span> <span class="n">context</span><span class="p">,</span> <span class="n">Func</span><span class="p">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">TOut</span><span class="p">&gt;</span> <span class="n">executeNext</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Basically, you get an input to operate on and a value to return. The <code>executeNext</code> parameter is a delegate for the next filter in the chain. The filters are composed together in a chain which is referred to as a Pipeline in the Tamarack framework. This structure is the essence of the Chain of Responsibility pattern and it facilitates some pretty cool things:</p>

<ul>
<li>Modify the input before the next filter gets it</li>
<li>Modify the output of the next filter before returning</li>
<li>Short circuit out of the chain by not calling the executeNext delegate</li>
</ul>


<h3>Show me examples!</h3>

<p>Consider a block of code to process a blog comment coming from a web-based rich text editor. There are probably several things you’ll want to do before letting the text into your database.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="kt">int</span> <span class="nf">Submit</span><span class="p">(</span><span class="n">Post</span> <span class="n">post</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="kt">var</span> <span class="n">pipeline</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Pipeline</span><span class="p">&lt;</span><span class="n">Post</span><span class="p">,</span> <span class="kt">int</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="k">new</span> <span class="n">CanoncalizeHtml</span><span class="p">())</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="k">new</span> <span class="n">StripMaliciousTags</span><span class="p">())</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="k">new</span> <span class="n">RemoveJavascript</span><span class="p">())</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="k">new</span> <span class="n">RewriteProfanity</span><span class="p">())</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="k">new</span> <span class="n">GuardAgainstDoublePost</span><span class="p">())</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Finally</span><span class="p">(</span><span class="n">p</span> <span class="p">=&gt;</span> <span class="n">repository</span><span class="p">.</span><span class="n">Save</span><span class="p">(</span><span class="n">p</span><span class="p">));</span>
</span><span class='line'>
</span><span class='line'>    <span class="kt">var</span> <span class="n">newId</span> <span class="p">=</span> <span class="n">pipeline</span><span class="p">.</span><span class="n">Execute</span><span class="p">(</span><span class="n">post</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="n">newId</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>What about dependency injection for complex filters? Take a look at this user login pipeline. Notice the generic syntax for adding filters by type. Those filters are built-up using the supplied implementation of <code>System.IServiceProvider</code>. My favorite is <code>UnityServiceProvider</code>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="kt">bool</span> <span class="nf">Login</span><span class="p">(</span><span class="kt">string</span> <span class="n">username</span><span class="p">,</span> <span class="kt">string</span> <span class="n">password</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="kt">var</span> <span class="n">pipeline</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Pipeline</span><span class="p">&lt;</span><span class="n">LoginContext</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;(</span><span class="n">serviceProvider</span><span class="p">)</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">&lt;</span><span class="n">WriteLoginAttemptToAuditLog</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">&lt;</span><span class="n">LockoutOnConsecutiveFailures</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">&lt;</span><span class="n">AuthenticateAgainstLocalStore</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">&lt;</span><span class="n">AuthenticateAgainstLdap</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Finally</span><span class="p">(</span><span class="n">c</span> <span class="p">=&gt;</span> <span class="k">false</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="n">pipeline</span><span class="p">.</span><span class="n">Execute</span><span class="p">(</span><span class="k">new</span> <span class="n">LoginContext</span><span class="p">(</span><span class="n">username</span><span class="p">,</span> <span class="n">password</span><span class="p">));</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Here’s another place you might see the chain of responsibility pattern. Calculating the spam score of a block of text:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="kt">double</span> <span class="nf">CalculateSpamScore</span><span class="p">(</span><span class="kt">string</span> <span class="n">text</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="kt">var</span> <span class="n">pipeline</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Pipeline</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">double</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">&lt;</span><span class="n">SpamCopBlacklistFilter</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">&lt;</span><span class="n">PerspcriptionDrugFilter</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Add</span><span class="p">&lt;</span><span class="n">PornographyFilter</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Finally</span><span class="p">(</span><span class="n">score</span> <span class="p">=&gt;</span> <span class="m">0</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="n">pipeline</span><span class="p">.</span><span class="n">Execute</span><span class="p">(</span><span class="n">text</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Prefer convention over configuration? Try this instead:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="kt">double</span> <span class="nf">CalculateSpamScore</span><span class="p">(</span><span class="kt">string</span> <span class="n">text</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="kt">var</span> <span class="n">pipeline</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Pipeline</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">double</span><span class="p">&gt;()</span>
</span><span class='line'>        <span class="p">.</span><span class="n">AddFiltersIn</span><span class="p">(</span><span class="s">&quot;Tamarack.Example.Pipeline.SpamScorer.Filters&quot;</span><span class="p">)</span>
</span><span class='line'>        <span class="p">.</span><span class="n">Finally</span><span class="p">(</span><span class="n">score</span> <span class="p">=&gt;</span> <span class="m">0</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="n">pipeline</span><span class="p">.</span><span class="n">Execute</span><span class="p">(</span><span class="n">text</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Let’s look at the <code>IFilter</code> interface in action. In the spam score calculator example, each filter looks for markers in the text and adds to the overall spam score by modifying the result of the next filter before returning.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">PerspcriptionDrugFilter</span> <span class="p">:</span> <span class="n">IFilter</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">double</span><span class="p">&gt;</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">public</span> <span class="kt">double</span> <span class="nf">Execute</span><span class="p">(</span><span class="kt">string</span> <span class="n">text</span><span class="p">,</span> <span class="n">Func</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">double</span><span class="p">&gt;</span> <span class="n">executeNext</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">score</span> <span class="p">=</span> <span class="n">executeNext</span><span class="p">(</span><span class="n">text</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">text</span><span class="p">.</span><span class="n">Contains</span><span class="p">(</span><span class="s">&quot;viagra&quot;</span><span class="p">))</span>
</span><span class='line'>            <span class="n">score</span> <span class="p">+=</span> <span class="p">.</span><span class="m">25</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">score</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>In the login example, we look for the user in our local user store and if it exists we’ll short-circuit the chain and authenticate the request. Otherwise we’ll let the request continue to the next filter which looks for the user in an LDAP repository.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">AuthenticateAgainstLocalStore</span> <span class="p">:</span> <span class="n">IFilter</span><span class="p">&lt;</span><span class="n">LoginContext</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">IUserRepository</span> <span class="n">repository</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="nf">AuthenticateAgainstLocalStore</span><span class="p">(</span><span class="n">IUserRepository</span> <span class="n">repository</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">repository</span> <span class="p">=</span> <span class="n">repository</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="kt">bool</span> <span class="nf">Execute</span><span class="p">(</span><span class="n">LoginContext</span> <span class="n">context</span><span class="p">,</span> <span class="n">Func</span><span class="p">&lt;</span><span class="n">LoginContext</span><span class="p">,</span> <span class="kt">bool</span><span class="p">&gt;</span> <span class="n">executeNext</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">user</span> <span class="p">=</span> <span class="n">repository</span><span class="p">.</span><span class="n">FindByUsername</span><span class="p">(</span><span class="n">context</span><span class="p">.</span><span class="n">Username</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">user</span> <span class="p">!=</span> <span class="k">null</span><span class="p">)</span>
</span><span class='line'>            <span class="k">return</span> <span class="n">user</span><span class="p">.</span><span class="n">IsValid</span><span class="p">(</span><span class="n">context</span><span class="p">.</span><span class="n">Password</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="nf">executeNext</span><span class="p">(</span><span class="n">context</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Why should I use it?</p>

<blockquote><p>It’s pretty much my favorite animal. It’s like a lion and a tiger mixed… bred for its skills in magic. – Napoleon Dynamite</p></blockquote>

<p>It’s simple and mildly opinionated in effort to guide you and your code into The Pit of Success. It’s easy to write single responsibility classes and use inversion of control and composition and convention over configuration and lots of other goodness. Try it out. Tell a friend.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[A Custom HttpModule to Log Request Duration]]></title>
    <link href="http://www.mikevalenty.com/a-custom-httpmodule-to-log-request-duration/"/>
    <updated>2011-01-16T02:31:00-08:00</updated>
    <id>http://www.mikevalenty.com/a-custom-httpmodule-to-log-request-duration</id>
    <content type="html"><![CDATA[<p>My application has logging of fine-grained operations, but I want to see the duration of the entire web request. The idea is to start a <code>Stopwatch</code> on the <code>BeginRequest</code> event and then log the elapsed time on the <code>EndRequest</code> event. I started by modifying the <code>Global.asax</code> to wire this up, but quickly got turned off because I was violating the Open-Closed Principle. I really just want to bolt-in this behavior while I’m profiling the application and then turn it off when the kinks are worked out. IIS has a pretty slick extension point for this sort of thing that let’s you hook into the request lifecycle events.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">RequestDurationLoggerModule</span> <span class="p">:</span> <span class="n">IHttpModule</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">const</span> <span class="kt">string</span> <span class="n">ContextItemKey</span> <span class="p">=</span> <span class="s">&quot;stopwatchContextItemKey&quot;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">void</span> <span class="nf">Init</span><span class="p">(</span><span class="n">HttpApplication</span> <span class="n">application</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">application</span><span class="p">.</span><span class="n">BeginRequest</span> <span class="p">+=</span> <span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span> <span class="p">=&gt;</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">application</span><span class="p">.</span><span class="n">Context</span><span class="p">.</span><span class="n">Items</span><span class="p">[</span><span class="n">ContextItemKey</span><span class="p">]</span> <span class="p">=</span> <span class="n">Stopwatch</span><span class="p">.</span><span class="n">StartNew</span><span class="p">();</span>
</span><span class='line'>        <span class="p">};</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">application</span><span class="p">.</span><span class="n">EndRequest</span> <span class="p">+=</span> <span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span> <span class="p">=&gt;</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="kt">var</span> <span class="n">stopwatch</span> <span class="p">=</span> <span class="p">(</span><span class="n">Stopwatch</span><span class="p">)</span><span class="n">application</span><span class="p">.</span><span class="n">Context</span><span class="p">.</span><span class="n">Items</span><span class="p">[</span><span class="n">ContextItemKey</span><span class="p">];</span>
</span><span class='line'>            <span class="n">stopwatch</span><span class="p">.</span><span class="n">Stop</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'>            <span class="kt">var</span> <span class="n">logger</span> <span class="p">=</span> <span class="n">GetLogger</span><span class="p">(</span><span class="n">application</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>            <span class="n">logger</span><span class="p">.</span><span class="n">Debug</span><span class="p">(</span>
</span><span class='line'>                <span class="s">&quot;{0} -&gt; [{1} ms]&quot;</span><span class="p">,</span>
</span><span class='line'>                <span class="n">application</span><span class="p">.</span><span class="n">Context</span><span class="p">.</span><span class="n">Request</span><span class="p">.</span><span class="n">RawUrl</span><span class="p">,</span>
</span><span class='line'>                <span class="n">stopwatch</span><span class="p">.</span><span class="n">ElapsedMilliseconds</span><span class="p">);</span>
</span><span class='line'>        <span class="p">};</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">private</span> <span class="k">static</span> <span class="n">ILogger</span> <span class="nf">GetLogger</span><span class="p">(</span><span class="n">HttpApplication</span> <span class="n">application</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">serviceProvider</span> <span class="p">=</span> <span class="n">application</span> <span class="k">as</span> <span class="n">IServiceProvider</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">serviceProvider</span> <span class="p">==</span> <span class="k">null</span><span class="p">)</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">NullLogger</span><span class="p">();</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">serviceProvider</span><span class="p">.</span><span class="n">GetService</span><span class="p">&lt;</span><span class="n">ILogger</span><span class="p">&gt;();</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">void</span> <span class="nf">Dispose</span><span class="p">()</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The only weird part here is getting a handle to the logger. I’m using an IoC container in my application, however I can’t tell IIS how to build up my <code>RequestDurationLoggerModule</code>, so I’m stuck using the Service Locator pattern. The container could be a singleton, but I don’t like singletons, so I implemented <code>IServiceProvider</code> in <code>Global.asax</code> instead. All that’s left now is wiring in the module. Since Cassini behaves like IIS6, you have to use the legacy style configuration, which looks like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'>  <span class="nt">&lt;system.web&gt;</span>
</span><span class='line'>    <span class="nt">&lt;httpModules&gt;</span>
</span><span class='line'>      <span class="nt">&lt;add</span> <span class="na">name=</span><span class="s">&quot;...&quot;</span> <span class="na">type=</span><span class="s">&quot;MyApplication.RequestDurationLoggerModule, MyApplication&quot;</span><span class="nt">/&gt;</span>
</span><span class='line'>    <span class="nt">&lt;/httpModules&gt;</span>
</span><span class='line'>  <span class="nt">&lt;/system.web&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>For IIS7 though, you add it like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'>  <span class="nt">&lt;system.webServer&gt;</span>
</span><span class='line'>    <span class="nt">&lt;modules&gt;</span>
</span><span class='line'>      <span class="nt">&lt;add</span> <span class="na">name=</span><span class="s">&quot;...&quot;</span> <span class="na">type=</span><span class="s">&quot;MyApplication.RequestDurationLoggerModule, MyApplication&quot;</span><span class="nt">/&gt;</span>
</span><span class='line'>    <span class="nt">&lt;/modules&gt;</span>
</span><span class='line'>  <span class="nt">&lt;/system.webServer&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Finally, it’s time to run the application and see the total request duration logged.</p>

<p><img class="plain" src="http://www.mikevalenty.com/images/posts/durationmodule.png"></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[A Proper Closure in C#]]></title>
    <link href="http://www.mikevalenty.com/a-proper-closure-in-csharp/"/>
    <updated>2010-12-18T20:46:00-08:00</updated>
    <id>http://www.mikevalenty.com/a-proper-closure-in-csharp</id>
    <content type="html"><![CDATA[<p>You’ve seen code like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">Order</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="n">ITaxCalculator</span> <span class="n">taxCalculator</span><span class="p">;</span>
</span><span class='line'>    <span class="k">private</span> <span class="kt">decimal?</span> <span class="n">tax</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="nf">Order</span><span class="p">(</span><span class="n">ITaxCalculator</span> <span class="n">taxCalculator</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">taxCalculator</span> <span class="p">=</span> <span class="n">taxCalculator</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="kt">decimal</span> <span class="nf">CalculateTax</span><span class="p">()</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(!</span><span class="n">tax</span><span class="p">.</span><span class="n">HasValue</span><span class="p">)</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">tax</span> <span class="p">=</span> <span class="n">taxCalculator</span><span class="p">.</span><span class="n">Calculate</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">tax</span><span class="p">.</span><span class="n">Value</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="p">...</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>There are a few things to pick at. I’m looking at the member variable named <code>tax</code> that is null until you call <code>CalculateTax</code> for the first time. There isn’t anything to prevent the rest of the class from using the tax variable directly and possibly repeating the null check code in multiple places. I thought it would be fun to rewrite it using a closure. I don’t mean the kind of accidental closures we write with LINQ, but an honest to goodness proper closure.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">Order</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">public</span> <span class="nf">Order</span><span class="p">(</span><span class="n">ITaxCalculator</span> <span class="n">taxCalculator</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">CalculateTax</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Func</span><span class="p">&lt;</span><span class="n">Func</span><span class="p">&lt;</span><span class="kt">decimal</span><span class="p">&gt;&gt;(()</span> <span class="p">=&gt;</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="kt">decimal?</span> <span class="n">tax</span> <span class="p">=</span> <span class="k">null</span><span class="p">;</span>
</span><span class='line'>            <span class="k">return</span> <span class="p">()</span> <span class="p">=&gt;</span>
</span><span class='line'>            <span class="p">{</span>
</span><span class='line'>                <span class="k">if</span> <span class="p">(!</span><span class="n">tax</span><span class="p">.</span><span class="n">HasValue</span><span class="p">)</span>
</span><span class='line'>                <span class="p">{</span>
</span><span class='line'>                    <span class="n">tax</span> <span class="p">=</span> <span class="n">taxCalculator</span><span class="p">.</span><span class="n">Calculate</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
</span><span class='line'>                <span class="p">}</span>
</span><span class='line'>                <span class="k">return</span> <span class="n">tax</span><span class="p">.</span><span class="n">Value</span><span class="p">;</span>
</span><span class='line'>            <span class="p">};</span>
</span><span class='line'>        <span class="p">})();</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="n">Func</span><span class="p">&lt;</span><span class="kt">decimal</span><span class="p">&gt;</span> <span class="n">CalculateTax</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="p">...</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>A closure is created around the tax variable so only the <code>CalculateTax</code> function has access to it. That’s pretty awesome. I wouldn’t have thought of using this technique before learning JavaScript all over again. It’s fun code to write, but it’s not going to get checked-in to source control. It’s basically a landmine for the next guy that has to make changes. The mental energy it takes to wrap your head around it is like listening to a joke with a really long setup and a lousy punch line. The solution is more complicated than the problem.</p>

<p>I still thought it was worth the mental exercise. Each language has its wheelhouse which makes a certain class of problems easy to solve. Admittedly this was a bit forced here, but opening your mind to other solutions may lead to a breakthrough solving a legitimately tough problem.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Refactoring C# Style]]></title>
    <link href="http://www.mikevalenty.com/refactoring-c-style/"/>
    <updated>2010-11-27T09:51:00-08:00</updated>
    <id>http://www.mikevalenty.com/refactoring-c-style</id>
    <content type="html"><![CDATA[<p>Take a look a this function.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="na">[UnitOfWork]</span>
</span><span class='line'><span class="k">public</span> <span class="k">virtual</span> <span class="k">void</span> <span class="nf">Upload</span><span class="p">(</span><span class="n">DocumentDto</span> <span class="n">dto</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="kt">var</span> <span class="n">entity</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Document</span><span class="p">().</span><span class="n">Merge</span><span class="p">(</span><span class="n">dto</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">stream</span> <span class="p">=</span> <span class="k">new</span> <span class="n">MemoryStream</span><span class="p">(</span><span class="n">dto</span><span class="p">.</span><span class="n">Data</span><span class="p">))</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">repository</span><span class="p">.</span><span class="n">Save</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">stream</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>After doing some performance profiling, it quickly popped up as the top offender. Why? Because it’s holding a database transaction open while saving a file. In order to fix it, we have to ditch our <code>UnitOfWork</code> aspect and implement a finer-grained transaction. Basically what needs to happen is saving the entity and saving the file need to be separate operations so we can commit the transaction as soon as the entity is saved. And since saving the file could fail, we might have to clean up an orphaned file entity.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
<span class='line-number'>53</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">virtual</span> <span class="k">void</span> <span class="nf">Upload</span><span class="p">(</span><span class="n">DocumentDto</span> <span class="n">dto</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="kt">var</span> <span class="n">entity</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Document</span><span class="p">().</span><span class="n">Merge</span><span class="p">(</span><span class="n">dto</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">SaveEntity</span><span class="p">(</span><span class="n">entity</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">try</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">SaveFile</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">dto</span><span class="p">.</span><span class="n">Data</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="k">catch</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">TryDeleteEntity</span><span class="p">(</span><span class="n">entity</span><span class="p">);</span>
</span><span class='line'>        <span class="k">throw</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">private</span> <span class="k">void</span> <span class="nf">SaveEntity</span><span class="p">(</span><span class="n">Document</span> <span class="n">entity</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Start</span><span class="p">();</span>
</span><span class='line'>    <span class="k">try</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">repository</span><span class="p">.</span><span class="n">Save</span><span class="p">(</span><span class="n">entity</span><span class="p">);</span>
</span><span class='line'>        <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Commit</span><span class="p">();</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="k">catch</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Rollback</span><span class="p">();</span>
</span><span class='line'>        <span class="k">throw</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">private</span> <span class="k">void</span> <span class="nf">SaveFile</span><span class="p">(</span><span class="n">Document</span> <span class="n">entity</span><span class="p">,</span> <span class="kt">byte</span><span class="p">[]</span> <span class="n">data</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">stream</span> <span class="p">=</span> <span class="k">new</span> <span class="n">MemoryStream</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">repository</span><span class="p">.</span><span class="n">Save</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">stream</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">private</span> <span class="k">void</span> <span class="nf">TryDeleteEntity</span><span class="p">(</span><span class="n">Document</span> <span class="n">entity</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Start</span><span class="p">();</span>
</span><span class='line'>    <span class="k">try</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">repository</span><span class="p">.</span><span class="n">Delete</span><span class="p">(</span><span class="n">entity</span><span class="p">);</span>
</span><span class='line'>        <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Commit</span><span class="p">();</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="k">catch</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Rollback</span><span class="p">();</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>That wasn’t too bad except that the number of lines of code exploded and we have a few private methods in our service that only deal with plumbing. It would be nice to push them into the framework. Since C# is awesome, we can use a combination of delegates and extension methods to do that.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
<span class='line-number'>53</span>
<span class='line-number'>54</span>
<span class='line-number'>55</span>
<span class='line-number'>56</span>
<span class='line-number'>57</span>
<span class='line-number'>58</span>
<span class='line-number'>59</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">virtual</span> <span class="k">void</span> <span class="nf">Upload</span><span class="p">(</span><span class="n">DocumentDto</span> <span class="n">dto</span><span class="p">)</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="kt">var</span> <span class="n">entity</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Document</span><span class="p">().</span><span class="n">Merge</span><span class="p">(</span><span class="n">dto</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Execute</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="n">repository</span><span class="p">.</span><span class="n">Save</span><span class="p">(</span><span class="n">entity</span><span class="p">));</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">try</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">repository</span><span class="p">.</span><span class="n">SaveFile</span><span class="p">(</span><span class="n">entity</span><span class="p">,</span> <span class="n">dto</span><span class="p">.</span><span class="n">Data</span><span class="p">);</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>    <span class="k">catch</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">unitOfWork</span><span class="p">.</span><span class="n">TryExecute</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="n">repository</span><span class="p">.</span><span class="n">Delete</span><span class="p">(</span><span class="n">entity</span><span class="p">));</span>
</span><span class='line'>        <span class="k">throw</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">public</span> <span class="k">static</span> <span class="k">class</span> <span class="nc">DocumentRepositoryExtensions</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">SaveFile</span><span class="p">(</span><span class="k">this</span> <span class="n">IDocumentRepository</span> <span class="n">repository</span><span class="p">,</span> <span class="n">Document</span> <span class="n">document</span><span class="p">,</span> <span class="kt">byte</span><span class="p">[]</span> <span class="n">data</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">stream</span> <span class="p">=</span> <span class="k">new</span> <span class="n">MemoryStream</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">repository</span><span class="p">.</span><span class="n">SaveFile</span><span class="p">(</span><span class="n">document</span><span class="p">,</span> <span class="n">stream</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="k">public</span> <span class="k">static</span> <span class="k">class</span> <span class="nc">UnitOfWorkExtensions</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">Execute</span><span class="p">(</span><span class="k">this</span> <span class="n">IUnitOfWork</span> <span class="n">unitOfWork</span><span class="p">,</span> <span class="n">Action</span> <span class="n">action</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Start</span><span class="p">();</span>
</span><span class='line'>        <span class="k">try</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">action</span><span class="p">.</span><span class="n">Invoke</span><span class="p">();</span>
</span><span class='line'>            <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Commit</span><span class="p">();</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>        <span class="k">catch</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Rollback</span><span class="p">();</span>
</span><span class='line'>            <span class="k">throw</span><span class="p">;</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">TryExecute</span><span class="p">(</span><span class="k">this</span> <span class="n">IUnitOfWork</span> <span class="n">unitOfWork</span><span class="p">,</span> <span class="n">Action</span> <span class="n">action</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Start</span><span class="p">();</span>
</span><span class='line'>        <span class="k">try</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">action</span><span class="p">.</span><span class="n">Invoke</span><span class="p">();</span>
</span><span class='line'>            <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Commit</span><span class="p">();</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>        <span class="k">catch</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">unitOfWork</span><span class="p">.</span><span class="n">Rollback</span><span class="p">();</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now we can move the extension methods into the framework and out of our service. In a less awesome language we could define these convenience methods on the <code>IUnitOfWork</code> interface and implement them in an abstract base class, but inheritance is evil and it’s a tradeoff we don’t have to make in C#.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Software Development Team Building – Part 1]]></title>
    <link href="http://www.mikevalenty.com/software-development-team-building-part-1/"/>
    <updated>2010-11-13T17:26:00-08:00</updated>
    <id>http://www.mikevalenty.com/software-development-team-building-part-1</id>
    <content type="html"><![CDATA[<p>The NHL season starts in October and ends 82 games later in April. Well, the regular season, that is. Hockey fans consider it an extended pre-season because when playoffs start, it’s like watching a different sport. To win the coveted Stanley Cup, a team must battle through four grueling best-of-seven series, and when it’s all over, it’s not about a bad call by the referee or a fluke fumble or broken tackle. It’s not even about a hot goal-tender or superstar forward. It’s about the whole team digging deep and banding together to create a whole greater than the sum of its parts.</p>

<p>If that wasn’t true, you could simply put all the best players on one team and watch them dominate. Russia tried it in the 2010 Winter Olympics and only walked away with the bronze medal. A successful team has an identity that transcends individuals. If you watch hockey, you’ll hear teams described as up-tempo, finesse, defensive or gritty and hard-hitting. One isn’t better than another, it really depends on what your core strengths are and then getting buy-in from everyone on the team.</p>

<p>On a software team, maybe you’ve got some pre-family twenty-something developers that are wizards with Javascript. Or, maybe you’ve got a veteran team and company with deep enough pockets to invest in a long term product strategy. It really doesn’t matter, just identify your strengths and get buy-in.</p>

<p>Developers are opinionated and not always team players; the cliché herding cats comes to mind. So how do you get developers to buy in? Try out this exercise. Get your team in front of a whiteboard and come up with a list of words that describe positive software quality factors. Here’s a start:</p>

<ul>
<li>Scalable</li>
<li>Fast</li>
<li>Efficient</li>
<li>Reliable</li>
<li>Maintainable</li>
<li>Elegant</li>
<li>Expressive</li>
<li>Readable</li>
<li>Portable</li>
<li>Concise</li>
<li>Testable</li>
<li>Understandable</li>
<li>Correct</li>
<li>Consistent</li>
<li>Clean</li>
<li>Innovative</li>
<li>Secure</li>
<li>Extensible</li>
<li>Reusable</li>
<li>Composable</li>
</ul>


<p>Have each team member to pick their top 5 and write them on the board. Compare the lists and allow the team to negotiate with each other to come up with a common top 3. Why is a shared list important? Writing software is about trade-offs. We make dozens of decisions per day while writing code and sharing a set of values is essential to consistent forward progress in a team environment.</p>

<blockquote><p>If you don’t know where you’re going, you might not get there – Yogi Berra</p></blockquote>

<p>Consider this list:</p>

<ul>
<li>Testable</li>
<li>Expressive</li>
<li>Scalable</li>
</ul>


<p>Compare that with:</p>

<ul>
<li>Innovative</li>
<li>Efficient</li>
<li>Elegant</li>
</ul>


<p>Imagine you are sitting at the keyboard working on a feature. Can you see how the first list could influence completely different decisions than the second list? It’s not about right or wrong, it’s just about being explicit about how you make decisions and trusting the rest of your team to make similar choices.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Automatic Deployment From TeamCity Using WebDeploy]]></title>
    <link href="http://www.mikevalenty.com/automatic-deployment-from-teamcity-using-webdeploy/"/>
    <updated>2010-10-27T11:07:00-07:00</updated>
    <id>http://www.mikevalenty.com/automatic-deployment-from-teamcity-using-webdeploy</id>
    <content type="html"><![CDATA[<p>A solid continuous integration strategy for an enterprise web application is more than just an automated build. You really need a layered approach to maintain a high level of confidence in your code base.</p>

<p><img class="plain" src="http://www.mikevalenty.com/images/posts/tcp1.jpg"></p>

<ol>
<li><strong>Run unit tests</strong> – these are fast running unit tests with no external dependencies. We use NUnit.</li>
<li><strong>Run integration tests</strong>  – these are tests that have a dependency on a database. The primarily purpose is to test NHibernate mappings.</li>
<li><strong>Run acceptance tests</strong> – these tests are written in the Given, When, Then style. We write the tests in BehaveN, but we expect that a stakeholder could read them and verify the business rules are correct.</li>
<li><strong>Deploy to CI and run UI tests</strong> – these are qunit and Selenium tests. They require the code to be deployed to a real web server before the tests run. That’s what this article is about.</li>
<li><strong>Deploy to QA</strong> – once the automated UI tests have passed, we deploy to our QA server for manual testing.</li>
</ol>


<p><strong>Step 1:</strong> <a href="http://weblogs.asp.net/scottgu/archive/2010/09/13/automating-deployment-with-microsoft-web-deploy.aspx">Install WebDeploy on the web server you want to deploy to.</a></p>

<p><strong>Step 2:</strong> <a href="http://blogs.msdn.com/b/webdevtools/archive/2009/05/04/web-deployment-web-config-transformation.aspx">Configure Web.config transforms.</a> This will enable you to change connection strings and whatnot based on your build configuration.</p>

<p>Currently this is only supported for web applications, but since it’s built on top of MSBuild tasks, you can do the same thing to an <code>App.config</code> with a little extra work. Take a peak at <code>Microsoft.Web.Publishing.targets</code> (C:\Program Files\MSBuild\Microsoft\VisualStudio\v10.0\Web) to see how to use the build tasks.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'><span class="nt">&lt;UsingTask</span> <span class="na">TaskName=</span><span class="s">&quot;TransformXml&quot;</span> <span class="na">AssemblyFile=</span><span class="s">&quot;Microsoft.Web.Publishing.Tasks.dll&quot;</span><span class="nt">/&gt;</span>
</span><span class='line'><span class="nt">&lt;UsingTask</span> <span class="na">TaskName=</span><span class="s">&quot;MSDeploy&quot;</span> <span class="na">AssemblyFile=</span><span class="s">&quot;Microsoft.Web.Publishing.Tasks.dll&quot;</span><span class="nt">/&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Step 3:</strong> Figure out the MSBuild command line arguments that work for your application. This took a bit of trial and error before landing on this:</p>

<pre>
C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe MyProject.sln 
  /p:Configuration=QA
  /p:OutputPath=bin
  /p:DeployOnBuild=True 
  /p:DeployTarget=MSDeployPublish 
  /p:MsDeployServiceUrl=https://myserver:8172/msdeploy.axd 
  /p:username=***** 
  /p:password=***** 
  /p:AllowUntrustedCertificate=True 
  /p:DeployIisAppPath=ci
  /p:MSDeployPublishMethod=WMSVC
</pre>


<p><strong>Step 4:</strong> Configure the Build Runner in TeamCity</p>

<p>Paste the command line parameters you figured out in Step 3 into the Build Runner configuration in TeamCity:</p>

<p><img class="plain" src="http://www.mikevalenty.com/images/posts/teamcity2.jpg"></p>

<p><strong>Step 5:</strong> Configure build dependencies in TeamCity. This means the integration tests will only run if the unit tests have passed and so on.</p>

<p><img class="plain" src="http://www.mikevalenty.com/images/posts/dep1.jpg"></p>

<p><img class="plain" src="http://www.mikevalenty.com/images/posts/snap1.jpg"></p>

<p><strong>Step 6:</strong> Write some code.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Hacker, Artist, Craftsman or Engineer?]]></title>
    <link href="http://www.mikevalenty.com/hacker-artist-craftsman-or-engineer/"/>
    <updated>2010-10-10T09:44:00-07:00</updated>
    <id>http://www.mikevalenty.com/hacker-artist-craftsman-or-engineer</id>
    <content type="html"><![CDATA[<p>I recently read the book <a href="http://www.codersatwork.com/">Coders at Work</a> on <a href="http://blargh.tommymontgomery.com/">tmont’s</a> recommendation. It was a good read, and at 500+ pages you can repurpose it as a monitor stand when you’re finished reading it.</p>

<blockquote><p>Based on nearly eighty hours of conversations with fifteen all-time great programmers and computer scientists, the Q&amp;A interviews in Coders at Work provide a multifaceted view into how great programmers learn to program, how they practice their craft, and what they think about the future of programming.</p></blockquote>

<p>The author, Peter Siebel, asked each of the interviewees “Do you consider yourself a hacker, artist, craftsman or engineer?” It’s a good question and one I forgot about until <a href="http://thecleancoder.blogspot.com/2010/09/hacker-novice-artist-and-craftsman.html">Uncle Bob wrote an article</a> suggesting a correlation with one’s definition of done. It’s a clever angle but there is more to explore.</p>

<h2>Hacker</h2>

<p>On a PDP-8 with only eight instructions and two registers, you’re going to need some ingenuity, maybe even the rare kind of intellect that led a 14 year-old to win eight United States Chess Championships in a row.</p>

<blockquote><p>It’s just you and your opponent at the board and you’re trying to prove something. — Bobby Fischer</p></blockquote>

<p>The hacker lives in a world of tight constraints, like Houdini in a straight jacket inside a locked box submerged in icy water. The hacker gets a thrill from this kind of challenge and often relies on a toolbox of algorithms and decompilers to get the job done. The hacker isn’t satisfied with mainstream abstractions for IO, instead the hacker knows exactly what happens when you write a file or open a socket and why you might choose UDP instead of TCP. The hacker is the guy that’s going to push the industry forward with new technology and techniques.</p>

<p>It’s a fine line though, finding loopholes and circumventing the intent of your framework can be a recipe for disaster. Often times, it’s not just you and the machine, it’s you and a team of developers writing software for users that expect their cell phone to stream music from Pandora via Bluetooth to their car stereo while rendering a map of the current location with real-time traffic info. And if all this takes a few extra seconds, your software is casually dismissed as a piece of crap.</p>

<h2>Artist</h2>

<p>The artist believes that software is an expression of one’s self. The process is creative and each solution is subtly unique like a brush stroke on a canvas. An artist believes what they do is special and you could no more teach someone how to be a great programmer than you could teach someone how to write a great song or novel. You’ve either got it or you don’t.</p>

<p>Just like a great band, truly great software comes from a small team with just the right mix of strengths and styles. Too many contributors and it’s a mess. Not enough and it’s too predictable. Boston was a great band, but it was dominated by Tom Schulz, the guitarist, keyboardist, songwriter and producer. He owned every note. It’s not necessarily a bad thing, Boston sold over 31 million albums in the United States. But consider the Beatles, two creative forces pushing and pulling on each other, clashing and meshing to produce a truly dynamic catalog.</p>

<h2>Craftsman</h2>

<p>If you’re having open heart surgery, you probably want an experienced doctor holding the scalpel. The human body is a complex system and reading a text book just isn’t the same as years of experience.</p>

<p>Programming is difficult. At its core, it is about managing complexity. Computer programs are the most complex things that humans make. Quality is illusive and elusive. – Douglas Crockford</p>

<p>When a fine furniture craftsman looks at a piece of wood, the unique shape and the location of the knots are thoughtfully considered. The craftsman observes how dry or green the wood is, how hard or soft it is and applies a set of best practices honed through years of experience to produce the finest end result.</p>

<p>The craftsman believes that most software problems are the same but knows a solution can’t be stamped out by code monkeys. Physical and financial constraints, subtleties of the problem domain and quirks of a particular framework or language require an experienced and steady hand to produce a quality product. The craftsman believes software development is a highly skilled trade and to become an expert you must start as an apprentice.</p>

<h2>Engineer</h2>

<p>An engineer writes the kind of software you count on when you drive a car, fly in a plane or dial 911; Where a failure means more than a delayed shipment or double payment on your online order. The stakes are high and the problems are too big to fit in one person’s head. Problems that only process and frameworks can wrangle. You can’t simply start typing and watch the design of your application emerge from nothing, it requires detailed analysis and thoughtful study.</p>

<p>Which one am I? I have a piece of paper that says Engineer on it, and while I enjoy writing frameworks as much as the next guy, I’m a craftsman. Maybe it’s because I’ve been doing this for a dozen years and I’d like to think my experience is worth more than a piece of paper.</p>

<blockquote><p>Hey, if you want me to take a dump in a box and mark it guaranteed, I will. I got spare time. But for now, for your customer’s sake, for your daughter’s sake, ya might wanna think about buying a quality product from me. – Tommy Boy</p></blockquote>

<p>Which one are you?</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Don't Say Singleton]]></title>
    <link href="http://www.mikevalenty.com/dont-say-singleton/"/>
    <updated>2010-09-18T22:10:00-07:00</updated>
    <id>http://www.mikevalenty.com/dont-say-singleton</id>
    <content type="html"><![CDATA[<p>I was in junior high around the time that Master of Puppets was released followed by <em>…And Justice For All</em>. Maybe it’s nostalgia, but those two albums were not only the best Metallica albums, they were perhaps the greatest albums of the entire genre. Something happened though and I don’t mean grunge.</p>

<p><img src="http://www.mikevalenty.com/images/posts/grunge_thumb.jpg"></p>

<p>Metallica eventually succumbed to their own success and tried to crank out albums more accessible to wider audiences. This tension between music with something to say and music that appeals to the masses has been the bane of the industry since the invention of the radio.</p>

<p>If you don’t believe me, go ask 10 people what their favorite Metallica song is. You’re going to hear Enter Sandman unless you work at an auto shop or maybe guitar center in which case you’re probably not reading this article. You’re going to hear Enter Sandman because that song was engineered by producers and marketing types to be played on the same radio stations that host morning shows like Jeff and Jer, yet that song couldn’t be further from the band’s roots.</p>

<p>Likewise, if you ask 10 programmers if they use design patterns, you will undoubtedly hear a resounding yes citing the widely accessible singleton pattern. Why is this the case? It’s because the singleton most closely resembles something that looks familiar when writing procedural code and it’s the easiest pattern to insert into a pile of crap. The problem is that the singleton represents design patterns about as well as Enter Sandman captures the essence of why Metallica was a great band.</p>

<p>Pattern catalogs should probably look more like this:</p>

<p><strong>Design Patterns:</strong></p>

<ul>
<li>Singleton*</li>
<li>Strategy</li>
<li>Decorator</li>
<li>…</li>
</ul>


<p><em>* Not a design pattern</em></p>

<p>Or at least come with a warning label.</p>

<blockquote><p>Warning: The Singleton is actually a global variable. Use this pattern as a last resort and be sure to hide the fact you are using it from the rest of your application and your manager.</p></blockquote>

<p>So how do you know if you’re using the Singleton correctly? I’ll give you a hint, if you have any knowledge of the fact that the object you’re using is a singleton, then you’re not using it correctly. Let’s say you’re writing some caching logic since it’s one of those places where singletons pop up.</p>

<p>Let’s start with a simple interface for finding a user object:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">interface</span> <span class="n">IUserRepository</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="n">User</span> <span class="nf">FindById</span><span class="p">(</span><span class="kt">int</span> <span class="n">id</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>You realize you keep doing the same lookup over and over and adding some caching would really perk up the application. Hooray, for the Singleton!</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">CachingUserRepository</span> <span class="p">:</span> <span class="n">SqlUserRepository</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">public</span> <span class="k">override</span> <span class="n">User</span> <span class="nf">FindById</span><span class="p">(</span><span class="kt">int</span> <span class="n">id</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">user</span> <span class="p">=</span> <span class="n">MyCache</span><span class="p">.</span><span class="n">Instance</span><span class="p">.</span><span class="n">Get</span><span class="p">(</span><span class="n">id</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">user</span> <span class="p">==</span> <span class="k">null</span><span class="p">)</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">user</span> <span class="p">=</span> <span class="k">base</span><span class="p">.</span><span class="n">FindById</span><span class="p">(</span><span class="n">id</span><span class="p">);</span>
</span><span class='line'>            <span class="n">MyCache</span><span class="p">.</span><span class="n">Instance</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">id</span><span class="p">,</span> <span class="n">user</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">user</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Well this probably works great in a console application or Windows service, but what if your code is running in a web application, or as a WCF service. What if your Windows service is distributed across multiple machines? Should you care how your application is deployed in your <code>CachingUserRepository</code>? No, you shouldn’t. That object has one responsibility, and it’s to manage collaboration with the cache. Let’s try this instead:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="k">public</span> <span class="k">class</span> <span class="nc">CachingUserRepository</span> <span class="p">:</span> <span class="n">SqlUserRepository</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">private</span> <span class="k">readonly</span> <span class="n">ICacheProvider</span><span class="p">&lt;</span><span class="n">User</span><span class="p">&gt;</span> <span class="n">cache</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="nf">CachingUserRepository</span><span class="p">(</span><span class="n">ICacheProvider</span><span class="p">&lt;</span><span class="n">User</span><span class="p">&gt;</span> <span class="n">cache</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">this</span><span class="p">.</span><span class="n">cache</span> <span class="p">=</span> <span class="n">cache</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">override</span> <span class="n">User</span> <span class="nf">FindById</span><span class="p">(</span><span class="kt">int</span> <span class="n">id</span><span class="p">)</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="kt">var</span> <span class="n">user</span> <span class="p">=</span> <span class="n">cache</span><span class="p">.</span><span class="n">Get</span><span class="p">(</span><span class="n">id</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">user</span> <span class="p">==</span> <span class="k">null</span><span class="p">)</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">user</span> <span class="p">=</span> <span class="k">base</span><span class="p">.</span><span class="n">FindById</span><span class="p">(</span><span class="n">id</span><span class="p">);</span>
</span><span class='line'>            <span class="n">cache</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="n">id</span><span class="p">,</span> <span class="n">user</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">user</span><span class="p">;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Maybe your cache should live for the lifetime of a single web request, or maybe a web session, or possibly a distributed cache is right for your scenario. The good news is that caching is one of those solved problems, like data access, so you can just pick your favorite library and plug it in to your application with a simple adapter:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='c#'><span class='line'><span class="n">HttpRequestCacheProvider</span>
</span><span class='line'><span class="n">HttpSessionCacheProvider</span>
</span><span class='line'><span class="n">HttpContextCacheProvider</span>
</span><span class='line'><span class="n">MemcacheCacheProvider</span>
</span><span class='line'><span class="n">EnterpriseLibraryCacheProvider</span>
</span><span class='line'><span class="n">VelocityCacheProvider</span>
</span></code></pre></td></tr></table></div></figure>


<p>Let’s say you still want to roll your own cache and you decide that singleton is right scope for you. That’s okay, just recognize that using a singleton is a configuration decision and should not leak out into your application. The only place that you should see that .Instance getter is where you bootstrap your application.</p>
]]></content>
  </entry>
  
</feed>