atom.xml

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

  <title><![CDATA[Continous Improvement]]></title>
  <link href="http://hkhan.github.com/atom.xml" rel="self"/>
  <link href="http://hkhan.github.com/"/>
  <updated>2015-06-06T19:59:44+01:00</updated>
  <id>http://hkhan.github.com/</id>
  <author>
    <name><![CDATA[Haroon Khan]]></name>
    
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[Y Combinator Derivation]]></title>
    <link href="http://hkhan.github.com/blog/2014/01/15/y-combinator-derivation/"/>
    <updated>2014-01-15T14:17:46+00:00</updated>
    <id>http://hkhan.github.com/blog/2014/01/15/y-combinator-derivation</id>
    <content type="html"><![CDATA[<p>One of the benefits of going through The Little Schemer, which I&rsquo;ve <a href="http://hkhan.github.com/blog/2014/01/14/review-little-schemer/">reviewed</a> recently is that it dedicates one of the later chapters solely to arriving at the <a href="http://en.wikipedia.org/wiki/Fixed-point_combinator#Y_combinator">Y combinator</a>. It starts with a constraint that a function definition is not allowed to refer to itself. Up till this point, recursion has been the key technique for computation but what if a language only contains anonymous functions. In this case, its not possible to refer to the function which is describing the computation. How can recursion be implemented in such a language?</p>

<!-- more -->


<p>This is an interesting and challenging exercise. Of course, its of little practical value in every day programming as all languages allow named function definitions. Nonetheless, its a fascinating question to ask and the real value is in the journey towards understanding and working through a problem methodically. The book provides a great step-by-step treatment of the problem but there are lots of ways to arrive at the solution. I&rsquo;ve found that each one gives new insights into functional programming techniques and ideas.</p>

<p>Here is a detailed derivation inspired by <a href="http://www.ps.uni-sb.de/courses/sem-prog97/material/YYWorks.ps">A Lecture on the Why of Y</a>.</p>

<div><script src='https://gist.github.com/8436742.js'></script>
<noscript><pre><code>#lang racket

(require rackunit)

;; Y combinator derivation in detailed steps 
;; (based on Why of Y derivation by Matthias Felleisen)  

;; Is it possible to define a recursive function without referrring to itself?
;; Sounds almost magical but lets give it a go.

;; Define a simple recursive function which refers to itself.
;; The aim is to remove the call to length from within itself.
(define (length l)
  (if (null? l) 0
      (add1 (length (cdr l)))))

(check-equal? (length &#39;(1 2 3)) 3)

;; Step 1: remove the recursive call to length.
;; Now it will work for length 0 but fail for everything else but its a start.
(define (length0 l)
  (if (null? l) 0
      (add1 (hukairs (cdr l)))))

;; aptly named as this function should never be called
(define (hukairs)
  (&quot;ERROR - should not get here&quot;))

(check-equal? (length0 &#39;()) 0)
; (check-equal? (length0 &#39;(x)) 2) FAIL

;; Step 2: now make it work for a list of length 1 by calling length0
(define (length1 l)
  (if (null? l) 0
      (add1 (length0 (cdr l)))))

(check-equal? (length1 &#39;()) 0)
(check-equal? (length1 &#39;(test)) 1)

;; Step 3: now make it work for list of length 2 by calling length1...I see a pattern
(define (length2 l)
  (if (null? l) 0
      (add1 (length1 (cdr l)))))

(check-equal? (length2 &#39;()) 0)
(check-equal? (length2 &#39;(test)) 1)
(check-equal? (length2 &#39;(x y)) 2)
; (check-equal? (length1 &#39;(x y z)) 3) FAIL

;; From here on in, we can just use anonymous functions instead of redefining functions
;; Step 4: rewrite length0 so that length reappears and we pass in the seed function
;; (which ofcourse shouldn&#39;t be called for list of length 0.
(
 ((lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l)))))) hukairs)
 &#39;())
;; -&gt; 0

;; Step 5: rewrite length1 in the same style as above where we immediately call the
;; new function passing in the length0 definition from Step 4
(
 ((lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l))))))
  ((lambda (length)                                ; &#39;inlined&#39; definition from step 4
     (lambda (l)
       (if (null? l) 0
           (add1 (length (cdr l)))))) hukairs))
 &#39;(1))
;; -&gt; 1

;; Step 6: rewrite length2 in the same style as above...I see a pattern here.
(
 ((lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l))))))
  ((lambda (length)
     (lambda (l)
       (if (null? l) 0
           (add1 (length (cdr l))))))
   ((lambda (length)
      (lambda (l)
        (if (null? l) 0
            (add1 (length (cdr l)))))) hukairs)))
 &#39;(1 2))
;; -&gt; 2

;; Step 7: back to length0 - extract the function which looks like length for length0.
;; Now we call the passed in function with hukairs which should never be called.
(
 ((lambda (mk-length)
    (mk-length hukairs))
  (lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l))))))) 
 &#39;())
;; -&gt; 0

;; Step 8: repeat the above step for length1 i.e. make another call to the
;; passed in length-like function
(
 ((lambda (mk-length)
    (mk-length (mk-length hukairs)))
  (lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l))))))) 
 &#39;(a))
;; -&gt; 1

;; Step 9: repeat for length2....I can see the pattern again.
(
 ((lambda (mk-length)
    (mk-length (mk-length (mk-length hukairs))))
  (lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l))))))) 
 &#39;(a b))
;; -&gt; 2

;; Step 10: repeat for length3...just to make sure.
(
 ((lambda (mk-length)
    (mk-length (mk-length (mk-length (mk-length hukairs)))))
  (lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l))))))) 
 &#39;(a b c))
;; -&gt; 3

;; Step 11: back to length0 variant - since we don&#39;t care about the hukairs,
;; we could pass mk-length to mk-length instead of hukairs and no one would care.
(
 ((lambda (mk-length)
    (mk-length mk-length))
  (lambda (mk-length)
    (lambda (l)
      (if (null? l) 0
          (add1 (mk-length (cdr l))))))) 
 &#39;())
;; -&gt; 0

;; Step 12: in order to create length1, we can now call the passed in function with
;; hukairs function as that will never be called
(
 ((lambda (mk-length)
    (mk-length mk-length))
  (lambda (mk-length)
    (lambda (l)
      (if (null? l) 0
          (add1 ((mk-length hukairs) (cdr l))))))) 
 &#39;(a))
;; -&gt; 1

;; Step 13: in order to create length2, we can replace hukairs with the passed in
;; mk-length which means that as the recursion process is about to terminate and it
;; requires one more call, it won&#39;t call mk-length with hukaris (which was the case
;; in previous steps). Instead it will call the passed-in function (mk-length) with
;; the same passed in function (mk-length) which can reach the termination condition
;; (null? l) or call itself again, if required....MAGIC
(
 ((lambda (mk-length)
    (mk-length mk-length))
  (lambda (mk-length)
    (lambda (l)
      (if (null? l) 0
          (add1 ((mk-length mk-length) (cdr l))))))) 
 &#39;(a b))
;; -&gt; 2

;; Now its just a matter of refactoring and generalizing
;; Step 14: extract the self application and call that length.
(
 ((lambda (mk-length)
    (mk-length mk-length))
  (lambda (mk-length)
    ((lambda (length)
       (lambda (l)
         (if (null? l) 0
             (add1 (length (cdr l))))))
     (lambda (x) ((mk-length mk-length) x)))))
 &#39;(a b c))
;; -&gt; 3

;; Step 15: extract the function which looks like length
(
 ((lambda (le)
    ((lambda (mk-length)
       (mk-length mk-length))
     (lambda (mk-length)
       (le (lambda (x) ((mk-length mk-length) x))))))
  (lambda (length)
    (lambda (l)
      (if (null? l) 0
          (add1 (length (cdr l)))))))
 &#39;(a b c))
;; -&gt; 3

;; Step 16: separate the function that makes length from the function
;; that looks like length (le). Notice that mk-length is bound separately in two
;; different scopes
(lambda (le)
  ((lambda (mk-length)                               
     (mk-length mk-length))
   (lambda (mk-length)
     (le (lambda (x) ((mk-length mk-length) x))))))
;; -&gt; &lt;procedure&gt;

;; Step 17: give the above a name Y and we have arrived at the Y-Combinator
(define (Y le)
  ((lambda (f) (f f))
   (lambda (g) (le (lambda (x) ((g g) x))))))

;; back to where we started from....define a function which look like length....
(define (f mk-length)
  (lambda (l)
    (if (null? l) 0
        (add1 (mk-length (cdr l))))))

;; and pass that to Y to return a function which is length (without referring to itself)
(define length-Y (Y f))

(check-equal? (length-Y &#39;(a b c d e)) 5)

;; also works for factorials and all other functions which can be defined recursively.
;; (fact is not referenced from within the body)
(define (fact n)
  ((Y (lambda (mk-fact)
        (lambda (n)
          (if (= n 0) 1
              (* n (mk-fact (- n 1))))))) n))

(check-equal? (fact 5) 120)

;; MAGICAL....did I hear Lambda Calculus......</code></pre></noscript></div>



]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Review: Little Schemer, Fourth Edition]]></title>
    <link href="http://hkhan.github.com/blog/2014/01/14/review-little-schemer/"/>
    <updated>2014-01-14T11:34:48+00:00</updated>
    <id>http://hkhan.github.com/blog/2014/01/14/review-little-schemer</id>
    <content type="html"><![CDATA[<p><a href="http://mitpress.mit.edu/books/little-schemer">The Little Schemer</a> is very different from the usual books on programming. It can probably be considered the first &lsquo;koan-style&rsquo; book - it presents a dialogue between a student and a teacher which is used to further the student&rsquo;s progress and understanding.</p>

<p>The book starts off with the very basics and gradually builds more and more complex ideas namely <a href="http://en.wikipedia.org/wiki/Recursion_(computer_science)">recursion</a>, <a href="http://en.wikipedia.org/wiki/Fixed-point_combinator#Y_combinator">Y combinator</a> and the <a href="http://en.wikipedia.org/wiki/Meta-circular_evaluator">metacirular evaluator</a>. The code translates seamlessly to Racket which is a modern descendent of Scheme and working in DrRacket is a very enjoyable experience. I adopted a TDD approach using RackUnit as the testing framework to give a red-green-refactor style workflow. Gradually, the idea of recursion begins to sink in, the fog begins to clear and the choice of Lisp for expressing these ideas becomes clear. Its a very liberating feeling to be able to express solutions using the very minimal set of constructs whilst taking a peek at what&rsquo;s so special about Lisp.</p>

<p>In short, this is a wonderful book which has something for everyone. For those new to Lisp and previously used to imperative style, its an eye-opener. It exposes the reader to elegant and beautiful ideas of computation through its learn-by-doing and learn-by-reflection approach. For curious minds, these are fascinating avenues for further exploration. I&rsquo;ve thoroughly enjoyed going through the exercises, grasping the ideas presented and learning some Lisp along the way. Its definitely on my recommendation list.</p>

<p>Arguably, you can get all this with SICP which gives a much more rigorous and formal treatment of these topics (and more) but this is so much more fun and that&rsquo;s what its about, isn&rsquo;t it?</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Builder With Lombok]]></title>
    <link href="http://hkhan.github.com/blog/2012/09/25/builder-with-lombok/"/>
    <updated>2012-09-25T14:41:35+01:00</updated>
    <id>http://hkhan.github.com/blog/2012/09/25/builder-with-lombok</id>
    <content type="html"><![CDATA[<p>The Builder Pattern is well known as an alternative to the constructors with multiple arguments; it increases code readability and the fluent interface allows object creation without passing null in the constructor etc. In a recent project, I was creating the domain objects and wanted to generate the builders for these objects cleanly and automatically; the less code the better. There are several Eclipse plugins that can generate the boilerplate code but there is a very clean way to remove the need for these plugins.</p>

<!-- more -->


<p><a href="https://github.com/peichhorn/lombok-pg">lombok-pg</a> provides an alternative. This library extends <a href="http://projectlombok.org/">Project Lombok</a> with even more funky stuff and one of those things is <code>@Builder</code>. The usage is best illustrated with a simple example.</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="kn">package</span> <span class="n">co</span><span class="o">.</span><span class="na">uk</span><span class="o">.</span><span class="na">agiletech</span><span class="o">.</span><span class="na">ecommerce</span><span class="o">.</span><span class="na">domain</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.List</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">lombok.Builder</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">lombok.Data</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Data</span>
</span><span class='line'><span class="nd">@Builder</span>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Customer</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">title</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">firstName</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">lastName</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">private</span> <span class="n">List</span><span class="o">&lt;</span><span class="n">Order</span><span class="o">&gt;</span> <span class="n">orders</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">hasOrders</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">return</span> <span class="n">orders</span> <span class="o">!=</span> <span class="kc">null</span> <span class="o">&amp;&amp;</span> <span class="n">orders</span><span class="o">.</span><span class="na">isEmpty</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 builder can then be used in the test cases with ease.</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='java'><span class='line'><span class="kn">package</span> <span class="n">co</span><span class="o">.</span><span class="na">uk</span><span class="o">.</span><span class="na">agiletech</span><span class="o">.</span><span class="na">ecommerce</span><span class="o">.</span><span class="na">domain</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">static</span> <span class="n">co</span><span class="o">.</span><span class="na">uk</span><span class="o">.</span><span class="na">agiletech</span><span class="o">.</span><span class="na">ecommerce</span><span class="o">.</span><span class="na">domain</span><span class="o">.</span><span class="na">Customer</span><span class="o">.</span><span class="na">customer</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">static</span> <span class="n">org</span><span class="o">.</span><span class="na">hamcrest</span><span class="o">.</span><span class="na">MatcherAssert</span><span class="o">.</span><span class="na">assertThat</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">static</span> <span class="n">org</span><span class="o">.</span><span class="na">hamcrest</span><span class="o">.</span><span class="na">Matchers</span><span class="o">.</span><span class="na">is</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">org.junit.Test</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">CustomerTest</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">Customer</span> <span class="n">customer</span><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">returnsFalseWhenCustomerHasNoOrders</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">customer</span> <span class="o">=</span> <span class="n">customer</span><span class="o">().</span><span class="na">title</span><span class="o">(</span><span class="s">&quot;Mr&quot;</span><span class="o">)</span>
</span><span class='line'>                             <span class="o">.</span><span class="na">firstName</span><span class="o">(</span><span class="s">&quot;John&quot;</span><span class="o">)</span>
</span><span class='line'>                             <span class="o">.</span><span class="na">lastName</span><span class="o">(</span><span class="s">&quot;Smith&quot;</span><span class="o">)</span>
</span><span class='line'>                             <span class="o">.</span><span class="na">build</span><span class="o">();</span>
</span><span class='line'>        <span class="n">assertThat</span><span class="o">(</span><span class="n">customer</span><span class="o">.</span><span class="na">hasOrders</span><span class="o">(),</span> <span class="n">is</span><span class="o">(</span><span class="kc">false</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[Git: A Simple Workflow]]></title>
    <link href="http://hkhan.github.com/blog/2011/11/26/git-a-simple-workflow/"/>
    <updated>2011-11-26T23:41:00+00:00</updated>
    <id>http://hkhan.github.com/blog/2011/11/26/git-a-simple-workflow</id>
    <content type="html"><![CDATA[<p>This is a very simple yet effective workflow in small teams to encourage knowledge sharing and improve code quality. I have been using this lately and seems to be working very well. The following illustrates the workflow assuming the upstream remote named &lsquo;origin&rsquo; on github.</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='bash'><span class='line'><span class="c"># create and switch to a new feature branch</span>
</span><span class='line'>git checkout -b new-feature
</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>
</pre></td><td class='code'><pre><code class='bash'><span class='line'><span class="c"># do some work on the feature branch and commit locally</span>
</span><span class='line'>git commit -m <span class="s1">&#39;Initial commit&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="c"># push the &#39;feature&#39; branch to remote &#39;origin&#39;</span>
</span><span class='line'>git push -u origin new-feature and <span class="nb">set </span>up tracking
</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>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>git commit -m <span class="s1">&#39;Some more feature work&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="c"># push some more commited work to remote</span>
</span><span class='line'>git push new-feature
</span></code></pre></td></tr></table></div></figure>


<p>Once the feature has been completed, raise a <strong>pull request</strong> which will result in a notification to the team members to review and merge the feature code into the master branch.</p>

<p>After successful code review and merging, get <strong>Hubot</strong> to deploy the master branch, test the feature and have a cup of tea!</p>
]]></content>
  </entry>
  
</feed>