Latest articles on xrefactor.comhttps://xrefactor.com/Philip Xupyx@xrefactor.com2016-12-31T04:43:20ZEna Batch Document ProcessorLinux Desktop Screenshots 2016https://xrefactor.com/blog/linux-desktop-screenshots-2016.html2016-12-31T04:20:07Z2016-12-31T04:20:07Z
<div class="section" id="linux-desktop-screenshots-2016">
<h1>Linux Desktop Screenshots 2016</h1>
<p>In keeping with tradition, here is what I used in 2016:</p>
<div class="figure">
<img alt="i3" src="../static/img/blog/ss2016/i3.png" />
<p class="caption">Four years in a row, <a class="reference external" href="http://i3wm.org/">i3</a></p>
</div>
<p>2016 was the year of computing. Leading the charge, <a class="reference external" href="https://en.wikipedia.org/wiki/AlphaGo">AlphaGo</a> and
<a class="reference external" href="https://www.tensorflow.org/">TensorFlow</a> are just the tip of the iceberg, with other breakthroughs in the
field of machine learning, 2016 was the year to be remembered.</p>
</div>
How to Use Mercurial as Git Front-endhttps://xrefactor.com/blog/how-to-use-mercurial-as-git-front-end.html2016-01-02T17:10:02Z2016-01-02T17:10:02Z
<div class="section" id="how-to-use-mercurial-as-git-front-end">
<h1>How to Use Mercurial as Git Front-end</h1>
<p>In this document, I am going to show you how to use <a class="reference external" href="https://www.mercurial-scm.org/">mercurial</a> as a <a class="reference external" href="https://git-scm.com/">git</a>
front-end. This is about a <strong>mercurial</strong> extension called <a class="reference external" href="http://hg-git.github.io/">Hg-Git</a>, if you
are already using it, or not going to use <strong>mercurial</strong> to push and pull from a
<strong>git</strong> server, then this guide is not for you.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">If you want to learn how to use <strong>mercurial</strong>, please check out the new
<a class="reference external" href="http://hgbook.org/">mercurial book</a>, it is free online.</p>
</div>
<div class="section" id="why-mercurial">
<h2>Why Mercurial?</h2>
<p>I hear you, why <strong>mercurial</strong>? Why, when seemingly open source projects are
migrating to <strong>git</strong> <em>en masse</em>? Why, when <strong>git</strong> and to some extent
<a class="reference external" href="https://github.com/">Github</a> had become the <em>de facto</em> tool-chain for OOS development? Why, when
<strong>python</strong> itself is <a class="reference external" href="https://mail.python.org/pipermail/core-workflow/2016-January/000345.html">moving away from mercurial</a> (actually, this document is
a response to this decision)? Isn't it the DVCS flame war long gone and
<strong>git</strong> is the declared winner? Isn't it <strong>mercurial</strong> no longer relevant,
like <a class="reference external" href="http://bazaar.canonical.com/">bzr</a> became long ago. This is 2016, not 2006 when both <strong>git</strong> and
<strong>mercurial</strong> are barely one-year-old.</p>
<p>To begin answering these questions, I need to state my observation first, that
the <strong>git</strong> dominance is not because of <strong>mercurial</strong> is a less capable
contender, it is mostly because of celebrity endorsement (<strong>git</strong> was written
by <a class="reference external" href="https://en.wikipedia.org/wiki/Linus_Torvalds">Linus Torvalds</a> and used in <a class="reference external" href="https://www.kernel.org/">Linux Kernel</a>) and <a class="reference external" href="https://github.com/">Github</a>'s dominance and
social lock down.</p>
<p>Feature-wise, there is no clear winner between <strong>git</strong> and <strong>mercurial</strong>
technically, in some scenarios <strong>git</strong> works better while in some cases
<strong>mercurial</strong> works better. So, there is no evidence that <strong>mercurial</strong> is
superior than <strong>git</strong>, why <strong>mercurial</strong>?</p>
<p>I am not going to get into details about these in this document, just pointing
out that <strong>mercurial</strong> has some unique features that one may find useful and
cannot be found in other alternatives, such as:</p>
<ol class="arabic simple">
<li>Specifically designed query languages <em>revset</em> and <em>fileset</em> for searching
in history</li>
<li>Built-in web server for quick one-off pulling/pushing/reviewing session</li>
<li>Extension for large files</li>
<li>Extension Mercurial Queues (mq), like multi-level index (in <strong>git</strong>'s
parlance), the mq patches can also be put under revision control</li>
<li>Phase, a feature that provide fine-grained control about changesets'
publicity, no more accidental push of secret, private changes</li>
<li><strong>Mercurial</strong> are easy to customize, read <a class="reference external" href="https://code.facebook.com/posts/218678814984400/scaling-mercurial-at-facebook/">scaling mercurial</a> for a real
world example</li>
<li>Some interesting ideas, like <a class="reference external" href="https://www.mercurial-scm.org/wiki/ChangesetEvolution">Changeset Evolution</a> for safe sharing of
history rewrites, most are experimental right now, though</li>
</ol>
<p>Nothing is perfect, <strong>mercurial</strong> is no exception, besides the smaller market
share, there is currently no plan to port the code base from python 2 to python
3 due to technical restriction. That being said, with those unique features
and intuitive user interface, <strong>mercurial</strong> is a viable option even today.</p>
<p>I am a strong believer in <em>"biodiversity and competition are good for a
ecosystem"</em>, this is another reason that I keep using <strong>mercurial</strong> and
promoting <strong>mercurial</strong> whenever possible, and the reason behind writing this
document.</p>
<p>Okay, enough talk, so how do we use <strong>mercurial</strong> as a <strong>git</strong> client? You
need an extension called <a class="reference external" href="http://hg-git.github.io/">Hg-Git</a>.</p>
</div>
<div class="section" id="installing-hg-git">
<h2>Installing Hg-Git</h2>
<p><strong>Hg-Git</strong> can be installed as normal <strong>mercurial</strong> extension, please follow
the instructions on the <a class="reference external" href="http://hg-git.github.io/">Hg-Git</a> official site. <strong>Hg-Git</strong> might as well be
able to be installed from your linux distribution's software repository
directly.</p>
<p>Please make sure both extensions <code>bookmarks</code> and <code>hggit</code> are
enabled afterward.</p>
<p>For example, with these lines in <code>~/.hgrc</code>:</p>
<pre class="code literal-block">
[extensions]
hgext.bookmarks =
hggit =
</pre>
</div>
<div class="section" id="talking-to-git-server">
<h2>Talking to Git Server</h2>
<p>When properly setup, you can use <code>hg clone</code>, <code>hg push</code> and
<code>hg pull</code> against a <strong>git</strong> server as if it is serving <strong>mercurial</strong>
repositories. Just remember the difference in uri schema, for example, to
clone from one of my projects on github, using <strong>git</strong>:</p>
<pre class="code sh literal-block">
git clone git@github.com:pyx/hymn.git
</pre>
<p>while using <strong>mercurial</strong>, the command will be:</p>
<pre class="code sh literal-block">
hg clone git+ssh://git@github.com/pyx/hymn.git
</pre>
<p>Notice the difference in schema part <code>git+ssh://</code> and the separator
<code>:</code> between host and user directory became a <code>/</code></p>
<p>You can simply <code>hg push</code> and <code>hg pull</code> from then on.</p>
</div>
<div class="section" id="caveat">
<h2>Caveat</h2>
<p><strong>Hg-Git</strong> keeps track of the changesets under the bookmark <code>master</code>, so
any destructive changes, e.g <code>hg strip</code> or <code>hg histedit</code> involving
<code>master</code> will be recorded and visible in <strong>git</strong>'s history. To avoid
this, deactivate bookmark <code>master</code> before applying any destructive
changes.</p>
<p>For the same reason, only history up to the point of <code>master</code> will be
pushed, and I suggest to first deactivate bookmark <code>master</code> while working
on development branches, you are supposed to checkout a <code>dev</code> branch
anyway, right?</p>
<p>It is so important that I have to mention again that, if you rewrite history
involving bookmark <code>master</code>, <strong>Hg-Git</strong> will record the changes while
<strong>mercurial</strong> will not, so things will get really messy if you forget about
that. Please work on development branches with bookmark <code>master</code>
deactivated, when you finish all the history rewriting and rebasing and the
changes are ready to be published, then and only then can you checkout
<code>master</code> and push the changes to a <strong>git</strong> server.</p>
<p><strong>Mercurial</strong> use explicit files to track some metadata, such as
<code>.hgtags</code> for tags, it is of no use to <strong>git</strong>, but it is there, and the
sha-1 hash for the same changeset is different in <strong>mercurial</strong> and <strong>git</strong>
because they have different strategies in calculating them, so keep that in mind.</p>
</div>
<div class="section" id="conclusion">
<h2>Conclusion</h2>
<p>With <strong>Hg-Git</strong>, one can use <strong>mercurial</strong> as a client for a <strong>git</strong> server,
and publishes <strong>mercurial</strong> repositories as <strong>git</strong> repositories at the same
time, without much work, this is how I managed to publish my open source
projects to both <a class="reference external" href="https://bitbucket.org">Bitbucket</a> (as <strong>mercurial</strong> repositories) and <a class="reference external" href="https://github.com/">Github</a>.
To people who prefer <strong>mercurial</strong> like me, but are forced to use <strong>git</strong>, it
is the best of both worlds.</p>
</div>
</div>
Linux Desktop Screenshots 2015https://xrefactor.com/blog/linux-desktop-screenshots-2015.html2015-12-31T21:17:27Z2015-12-31T21:17:27Z
<div class="section" id="linux-desktop-screenshots-2015">
<h1>Linux Desktop Screenshots 2015</h1>
<p>What I used in 2015:</p>
<div class="figure">
<img alt="i3" src="../static/img/blog/ss2015/i3.png" />
<p class="caption">Boring as always, that's the norm with tiling wm, still <a class="reference external" href="http://i3wm.org/">i3</a></p>
</div>
<p>Since <a class="reference external" href="https://perl6.org/">perl 6</a> was released few days ago, I guess 2015 was the year of linux
desktop, too. :)</p>
</div>
R.I.P Ian Murdockhttps://xrefactor.com/blog/rip-ian-murdock.html2015-12-30T23:19:05Z2015-12-30T23:19:05Z
<div class="section" id="r-i-p-ian-murdock">
<h1>R.I.P Ian Murdock</h1>
<p>It was a shock to hear the news of the passing of <a class="reference external" href="https://en.wikipedia.org/wiki/Ian_Murdock">Ian Murdock</a> (1973-2015),
the creator of <a class="reference external" href="https://www.debian.org/">Debian</a>.</p>
<p>As the father of Debian, the second oldest GNU/Linux distribution that is still
in widely used and in existence (the oldest being Slackware), Ian Murdock was a
true pioneer, his great contribution to the Open Source Movement and in
building a healthy open source community benefits us all and helped make the
world a better place.</p>
<p>Debian is the first ever open source operating system I used, and am still
using day-to-day, for over a decade. It is also the go-to distro for new
installations whenever I do not need the flexibility of compiling from source.
Like many others, I've learned a lot from the project, the community, and the
people therein.</p>
<p>It is a tragic loss for his family and for our open source community, he will
be terribly missed, may his soul rest in peace.</p>
<p>My sincere condolences.</p>
</div>
The Frist Public Release of Hymnhttps://xrefactor.com/blog/the-first-public-release-of-hymn.html2015-12-09T20:45:21Z2015-12-09T20:45:21Z
<div class="section" id="the-frist-public-release-of-hymn">
<h1>The Frist Public Release of Hymn</h1>
<p>I am happy to announce the first public release of <a class="reference external" href="https://xrefactor.com/projects/hymn">hymn</a>, a new <a class="reference external" href="https://en.wikipedia.org/wiki/Monad_%28functional_programming%29">monad</a>
library for <a class="reference external" href="http://hylang.org/">Hy</a> and <a class="reference external" href="https://www.python.org/">Python</a>. In addition to implementing many common monad
types, with the help of lisp macro, it is possible to write monadic code in do
notation, like so (example in Reader Monad):</p>
<pre class="code clojure literal-block">
<span class="nv">=></span> <span class="p">(</span><span class="nf">require</span> <span class="nv">hymn.dsl</span><span class="p">)</span>
<span class="nv">=></span> <span class="p">(</span><span class="nb">import </span><span class="p">[</span><span class="nv">hymn.types.reader</span> <span class="p">[</span><span class="nv">lookup</span><span class="p">]])</span>
<span class="nv">=></span> <span class="c1">;; do notation with reader monad, lookup assumes the environment is subscriptable</span>
<span class="nv">=></span> <span class="p">(</span><span class="k">def </span><span class="nv">r</span> <span class="p">(</span><span class="nf">do-monad</span> <span class="p">[</span><span class="nv">a</span> <span class="p">(</span><span class="nf">lookup</span> <span class="ss">'a</span><span class="p">)</span> <span class="nv">b</span> <span class="p">(</span><span class="nf">lookup</span> <span class="ss">'b</span><span class="p">)]</span> <span class="p">(</span><span class="nb">+ </span><span class="nv">a</span> <span class="nv">b</span><span class="p">)))</span>
<span class="nv">=></span> <span class="c1">;; run reader monad r with environment</span>
<span class="nv">=></span> <span class="p">(</span><span class="nf">.run</span> <span class="nv">r</span> <span class="p">{</span><span class="ss">'a</span> <span class="mi">1</span> <span class="ss">'b</span> <span class="mi">2</span><span class="p">})</span>
<span class="mi">3</span>
</pre>
<p>I also wrote some interesting examples with it, just check out the
<code>examples</code> directory, to get a taste of it, here is the example that
using writer monad for logging:</p>
<pre class="code clojure literal-block">
<span class="p">(</span><span class="nb">import </span><span class="p">[</span><span class="nv">hymn.dsl</span> <span class="p">[</span><span class="nv">tell</span><span class="p">]])</span>
<span class="p">(</span><span class="nf">require</span> <span class="nv">hymn.dsl</span><span class="p">)</span>
<span class="p">(</span><span class="kd">defn </span><span class="nv">gcd</span> <span class="p">[</span><span class="nv">a</span> <span class="nv">b</span><span class="p">]</span>
<span class="p">(</span><span class="k">if </span><span class="p">(</span><span class="nb">zero? </span><span class="nv">b</span><span class="p">)</span>
<span class="p">(</span><span class="nf">do-monad</span>
<span class="p">[</span><span class="nv">_</span> <span class="p">(</span><span class="nf">tell</span> <span class="p">(</span><span class="nf">.format</span> <span class="s">"the result is: {}\n"</span> <span class="p">(</span><span class="nf">abs</span> <span class="nv">a</span><span class="p">)))]</span>
<span class="p">(</span><span class="nf">abs</span> <span class="nv">a</span><span class="p">))</span>
<span class="p">(</span><span class="nf">do-monad-m</span>
<span class="p">[</span><span class="nv">_</span> <span class="p">(</span><span class="nf">tell</span> <span class="p">(</span><span class="nf">.format</span> <span class="s">"{} mod {} = {}\n"</span> <span class="nv">a</span> <span class="nv">b</span> <span class="p">(</span><span class="nf">%</span> <span class="nv">a</span> <span class="nv">b</span><span class="p">)))]</span>
<span class="p">(</span><span class="nf">gcd</span> <span class="nv">b</span> <span class="p">(</span><span class="nf">%</span> <span class="nv">a</span> <span class="nv">b</span><span class="p">)))))</span>
<span class="p">(</span><span class="nf">defmain</span> <span class="p">[</span><span class="o">&</span><span class="nb">rest </span><span class="nv">args</span><span class="p">]</span>
<span class="p">(</span><span class="k">if </span><span class="p">(</span><span class="nb">-> </span><span class="nv">args</span> <span class="nv">len</span> <span class="p">(</span><span class="nf">!=</span> <span class="mi">3</span><span class="p">))</span>
<span class="p">(</span><span class="nb">print </span><span class="s">"usage:"</span> <span class="p">(</span><span class="nb">get </span><span class="nv">args</span> <span class="mi">0</span><span class="p">)</span> <span class="s">"number1 number2"</span><span class="p">)</span>
<span class="p">(</span><span class="k">let </span><span class="p">[[</span><span class="nv">a</span> <span class="p">(</span><span class="nb">int </span><span class="p">(</span><span class="nb">get </span><span class="nv">args</span> <span class="mi">1</span><span class="p">))]</span>
<span class="p">[</span><span class="nv">b</span> <span class="p">(</span><span class="nb">int </span><span class="p">(</span><span class="nb">get </span><span class="nv">args</span> <span class="mi">2</span><span class="p">))]]</span>
<span class="p">(</span><span class="nb">print </span><span class="s">"calculating the greatest common divisor of"</span> <span class="nv">a</span> <span class="s">"and"</span> <span class="nv">b</span><span class="p">)</span>
<span class="p">(</span><span class="nb">print </span><span class="p">(</span><span class="nf">.execute</span> <span class="p">(</span><span class="nf">gcd</span> <span class="nv">a</span> <span class="nv">b</span><span class="p">))))))</span>
</pre>
<p>And here is the state monad example, using monte carlo method to calculate pi:</p>
<pre class="code clojure literal-block">
<span class="p">(</span><span class="nf">import</span>
<span class="p">[</span><span class="nv">collections</span> <span class="p">[</span><span class="nv">Counter</span><span class="p">]]</span>
<span class="p">[</span><span class="nb">time </span><span class="p">[</span><span class="nv">time</span><span class="p">]]</span>
<span class="p">[</span><span class="nv">hymn.dsl</span> <span class="p">[</span><span class="nv">get-state</span> <span class="nb">replicate </span><span class="nv">set-state</span><span class="p">]])</span>
<span class="p">(</span><span class="nf">require</span> <span class="nv">hymn.dsl</span><span class="p">)</span>
<span class="c1">;;; Knuth!</span>
<span class="p">(</span><span class="k">def </span><span class="nv">a</span> <span class="mi">6364136223846793005</span><span class="p">)</span>
<span class="p">(</span><span class="k">def </span><span class="nv">c</span> <span class="mi">1442695040888963407</span><span class="p">)</span>
<span class="p">(</span><span class="k">def </span><span class="nv">m</span> <span class="p">(</span><span class="nf">**</span> <span class="mi">2</span> <span class="mi">64</span><span class="p">))</span>
<span class="c1">;;; linear congruential generator</span>
<span class="p">(</span><span class="k">def </span><span class="nv">random</span>
<span class="p">(</span><span class="nf">do-monad</span>
<span class="p">[</span><span class="nv">seed</span> <span class="nv">get-state</span>
<span class="nv">_</span> <span class="p">(</span><span class="nf">set-state</span> <span class="p">(</span><span class="nb">-> </span><span class="nv">seed</span> <span class="p">(</span><span class="nb">* </span><span class="nv">a</span><span class="p">)</span> <span class="p">(</span><span class="nb">+ </span><span class="nv">c</span><span class="p">)</span> <span class="p">(</span><span class="nf">%</span> <span class="nv">m</span><span class="p">)))</span>
<span class="nv">new-seed</span> <span class="nv">get-state</span><span class="p">]</span>
<span class="p">(</span><span class="nb">/ </span><span class="nv">new-seed</span> <span class="nv">m</span><span class="p">)))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">random-point</span> <span class="p">(</span><span class="nf">do-monad</span> <span class="p">[</span><span class="nv">x</span> <span class="nv">random</span> <span class="nv">y</span> <span class="nv">random</span><span class="p">]</span> <span class="p">(</span>, <span class="nv">x</span> <span class="nv">y</span><span class="p">)))</span>
<span class="p">(</span><span class="kd">defn </span><span class="nv">points</span> <span class="p">[</span><span class="nv">seed</span><span class="p">]</span>
<span class="s">"stream of random points"</span>
<span class="p">(</span><span class="nf">while</span> <span class="nv">true</span>
<span class="c1">;; NOTE:</span>
<span class="c1">;; limited by the maximum recursion depth, we take 150 points each time</span>
<span class="p">(</span><span class="nf">setv</span> <span class="p">[</span><span class="nv">random-points</span> <span class="nv">seed</span><span class="p">]</span> <span class="p">(</span><span class="nf">.run</span> <span class="p">(</span><span class="nb">replicate </span><span class="mi">150</span> <span class="nv">random-point</span><span class="p">)</span> <span class="nv">seed</span><span class="p">))</span>
<span class="p">(</span><span class="nb">for </span><span class="p">[</span><span class="nv">point</span> <span class="nv">random-points</span><span class="p">]</span>
<span class="p">(</span><span class="nf">yield</span> <span class="nv">point</span><span class="p">))))</span>
<span class="p">(</span><span class="kd">defn </span><span class="nv">monte-carlo</span> <span class="p">[</span><span class="nv">number-of-points</span><span class="p">]</span>
<span class="s">"use monte carlo method to calculate value of pi"</span>
<span class="p">(</span><span class="k">def </span><span class="nv">samples</span> <span class="p">(</span><span class="nb">take </span><span class="nv">number-of-points</span> <span class="p">(</span><span class="nf">points</span> <span class="p">(</span><span class="nb">int </span><span class="p">(</span><span class="nf">time</span><span class="p">)))))</span>
<span class="p">(</span><span class="k">def </span><span class="nv">result</span>
<span class="p">(</span><span class="nf">Counter</span> <span class="p">(</span><span class="nf">genexpr</span> <span class="p">(</span><span class="nb">>= </span><span class="mf">1.0</span> <span class="p">(</span><span class="nb">+ </span><span class="p">(</span><span class="nf">**</span> <span class="nv">x</span> <span class="mi">2</span><span class="p">)</span> <span class="p">(</span><span class="nf">**</span> <span class="nv">y</span> <span class="mi">2</span><span class="p">)))</span> <span class="p">[[</span><span class="nv">x</span> <span class="nv">y</span><span class="p">]</span> <span class="nv">samples</span><span class="p">])))</span>
<span class="p">(</span><span class="nb">-> </span><span class="nv">result</span> <span class="p">(</span><span class="nb">get </span><span class="nv">true</span><span class="p">)</span> <span class="p">(</span><span class="nb">/ </span><span class="nv">number-of-points</span><span class="p">)</span> <span class="p">(</span><span class="nb">* </span><span class="mi">4</span><span class="p">)))</span>
<span class="p">(</span><span class="nf">defmain</span> <span class="p">[</span><span class="o">&</span><span class="nb">rest </span><span class="nv">args</span><span class="p">]</span>
<span class="p">(</span><span class="k">if </span><span class="p">(</span><span class="nb">-> </span><span class="nv">args</span> <span class="nv">len</span> <span class="p">(</span><span class="nf">!=</span> <span class="mi">2</span><span class="p">))</span>
<span class="p">(</span><span class="nb">print </span><span class="s">"usage:"</span> <span class="p">(</span><span class="nb">get </span><span class="nv">args</span> <span class="mi">0</span><span class="p">)</span> <span class="s">"number-of-points"</span><span class="p">)</span>
<span class="p">(</span><span class="nb">print </span><span class="s">"the estimate for pi ="</span> <span class="p">(</span><span class="nb">-> </span><span class="nv">args</span> <span class="p">(</span><span class="nb">get </span><span class="mi">1</span><span class="p">)</span> <span class="nb">int </span><span class="nv">monte-carlo</span><span class="p">))))</span>
</pre>
<p>This should replace the older <a class="reference external" href="https://xrefactor.com/projects/monad">monad library</a>.</p>
</div>
Linux Desktop Screenshots 2014https://xrefactor.com/blog/linux-desktop-screenshots-2014.html2014-12-31T16:03:45Z2014-12-31T16:03:45Z
<div class="section" id="linux-desktop-screenshots-2014">
<h1>Linux Desktop Screenshots 2014</h1>
<p>What I used in 2014:</p>
<div class="figure">
<img alt="i3" src="../static/img/blog/ss2014/i3.png" />
<p class="caption">Nothing changed, except wallpapers, <a class="reference external" href="http://i3wm.org/">i3</a></p>
</div>
</div>
2048 in OCamlhttps://xrefactor.com/blog/2048-in-ocaml.html2014-03-21T11:56:14Z2014-03-21T11:56:14Z
<div class="section" id="in-ocaml">
<h1>2048 in OCaml</h1>
<div class="section" id="a-new-flappy-bird">
<h2>A New Flappy Bird</h2>
<p>Have you ever heard about a game called <a class="reference external" href="https://github.com/gabrielecirulli/2048/">2048</a>? There are discussions about it
everywhere recently, be it on <em>Stack Overflow</em>, <em>hacker news</em>, <em>reddit</em>,
<em>twitter</em>, <em>facebook</em>, you name it. It even got its own <a class="reference external" href="http://en.wikipedia.org/wiki/2048_%28game%29">wikipedia entry</a>.</p>
<p>The gameplay is simple, you have a 4 x 4 grid with numbers, you can move all
tiles in four directions, while moving, a couple adjacent tiles with same
number will collide and be merged into a new tile with the number of their
values added up, a new tile with number 2 or 4 will also appear randomly after
each move, your goal is to come up with a tile with value <strong>2048</strong> <em>(hence the
name)</em> before the game board is too crowded for new tile, in which case, you
lose the game.</p>
<p>If you haven't already, please try to play it a few times, it's quite
straightforward and fun to play, yet challenging and somewhat addictive. You
will not regret, or you will, for it's such a time sink.</p>
</div>
<div class="section" id="nih-syndrome-anybody">
<h2>NIH Syndrome, anybody?</h2>
<p>Do you know what's more fun to do? <a class="reference external" href="https://en.wikipedia.org/wiki/Eating_your_own_dog_food">Dogfooding</a>, that's correct, write your
own version of <strong>2048</strong>, because that's fun and doable in a few hours. This is
why all the cool kids in town were busy reimplementing <strong>2048</strong> using their
favorite programming languages lately.</p>
<p>In just a few days, I have seen many implementations and variants, in varying
languages and technologies: <em>javascript</em> (same as the original one), <em>C</em>,
<em>C++</em>, <em>java</em>, <em>C#</em>, <em>python</em>, <em>ruby</em>, <em>Objective-C</em>, <em>haskell</em>, etc., and the
number keeps growing.</p>
<p>It seems like this thing is becoming the new <a class="reference external" href="https://en.wikipedia.org/wiki/Hello_world_program">Hello world</a>, just like
<em>"roll-your-own-static-website-generator"</em> was last year, and
<em>"write-your-own-dynamic-blog-engine-with-a-framework"</em> a few years before
that.</p>
<p>What I found interesting is, the game can make good use of <a class="reference external" href="https://en.wikipedia.org/wiki/Monad_%28functional_programming%29">monad</a>, each game
move can be implemented as <strong>monadic function</strong> and be chained, composed,
transformed as such. So, with that pattern, I wrote <a class="reference external" href="https://xrefactor.com/projects/2048-ml">my own version</a> of
<strong>2048</strong>, in <a class="reference external" href="http://ocaml.org/">OCaml</a>.</p>
</div>
<div class="section" id="monadic-wtf">
<h2>Monadic WTF?</h2>
<p>For one thing, <strong>monad</strong> yields beautiful code, for example, the following code
snippet from my version shows how to initialize a game board and then place two
tiles randomly to begin with:</p>
<pre class="code ocaml literal-block">
<span class="k">let</span> <span class="n">init</span> <span class="n">x</span> <span class="n">y</span> <span class="o">=</span>
<span class="nn">Random</span><span class="p">.</span><span class="n">self_init</span> <span class="bp">()</span><span class="o">;</span>
<span class="k">let</span> <span class="n">board</span> <span class="o">=</span> <span class="nn">Board</span><span class="p">.</span><span class="n">init</span> <span class="n">x</span> <span class="n">y</span> <span class="k">in</span>
<span class="k">let</span> <span class="k">open</span> <span class="nc">Infix</span> <span class="k">in</span>
<span class="n">playing</span> <span class="n">board</span> <span class="o">>>=</span> <span class="n">spawn</span> <span class="o">>>=</span> <span class="n">spawn</span>
</pre>
<p>Notice how I implemented this action <em>"placing a new tile randomly"</em>, as a
<em>monadic function</em> (<code>spawn</code>) and how actions are chained with <em>bind
operator</em> (<code>>>=</code>), magnificent, isn't it?.</p>
<p>You don't have to be able to read <em>OCaml</em> to agree.</p>
<p>The following shows how to handle move:</p>
<pre class="code ocaml literal-block">
<span class="k">let</span> <span class="n">move</span> <span class="n">m</span> <span class="n">game</span> <span class="o">=</span>
<span class="k">let</span> <span class="k">open</span> <span class="nc">Infix</span> <span class="k">in</span>
<span class="k">let</span> <span class="n">action</span> <span class="o">=</span> <span class="k">match</span> <span class="n">m</span> <span class="k">with</span>
<span class="o">|</span> <span class="nc">Up</span> <span class="o">-></span> <span class="nn">Board</span><span class="p">.</span><span class="n">move_up</span>
<span class="o">|</span> <span class="nc">Down</span> <span class="o">-></span> <span class="nn">Board</span><span class="p">.</span><span class="n">move_down</span>
<span class="o">|</span> <span class="nc">Left</span> <span class="o">-></span> <span class="nn">Board</span><span class="p">.</span><span class="n">move_left</span>
<span class="o">|</span> <span class="nc">Right</span> <span class="o">-></span> <span class="nn">Board</span><span class="p">.</span><span class="n">move_right</span>
<span class="k">in</span> <span class="nn">Monad</span><span class="p">.</span><span class="n">lift</span> <span class="n">action</span> <span class="n">game</span> <span class="o">>>=</span> <span class="n">spawn</span>
</pre>
<p>See how we combine <em>"making a move"</em> (<code>Monad.lift action game</code>) with
<em>"placing a new tile"</em> (<code>spawn</code>) then <em>"checking for game winning/losing
condition"</em> (<code>check</code>) automatically by <em>bind</em> function, as follows:</p>
<pre class="code ocaml literal-block">
<span class="k">let</span> <span class="n">bind</span> <span class="n">game</span> <span class="n">action</span> <span class="o">=</span>
<span class="k">match</span> <span class="n">game</span> <span class="k">with</span>
<span class="o">|</span> <span class="nc">Playing</span><span class="o">,</span> <span class="n">board</span> <span class="o">-></span>
<span class="k">begin</span> <span class="k">match</span> <span class="n">action</span> <span class="n">board</span> <span class="k">with</span>
<span class="o">|</span> <span class="nc">Playing</span><span class="o">,</span> <span class="n">board'</span> <span class="o">-></span> <span class="n">check</span> <span class="n">board'</span>
<span class="o">|</span> <span class="n">game</span> <span class="o">-></span> <span class="n">game</span>
<span class="k">end</span>
<span class="o">|</span> <span class="n">game</span> <span class="o">-></span> <span class="n">game</span>
<span class="k">let</span> <span class="o">(</span> <span class="o">>>=</span> <span class="o">)</span> <span class="o">=</span> <span class="nn">Monad</span><span class="p">.</span><span class="n">bind</span>
</pre>
<p>As you can see, the <em>bind</em> function is smart enough to stop taking moves when
the game has finished. That is, if we are trying to play an action on a
finished game, nothing will happen but passing the game object through the
chain as it is, without explicit testing in each action function. Talk about
avoiding boilerplate code again.</p>
<div class="admonition hint">
<p class="first admonition-title">Hint</p>
<p class="last">More specifically, the <em>game-board</em> object is modelled as a <a class="reference external" href="https://en.wikipedia.org/wiki/Writer_monad#Writer_monad">Writer Monad</a>,
tuple of (<em>grid</em>, <em>step-count</em>, <em>score</em>), while the game object is modelled
as something similar to <a class="reference external" href="https://en.wikipedia.org/wiki/Writer_monad#The_Maybe_monad">the Maybe Monad</a>, tuple of (<em>game-state</em>,
<em>game-board</em>). Each game action takes a <em>game-board</em> and yields, as after
the action taken, the <em>game-board</em> in which contains updated <em>step-count</em> and
<em>score</em>. The <em>bind</em> function takes responsibility for chaining game actions
in turn, accumulating <em>step-count</em> and <em>score</em>, and updating <em>game-state</em>
afterward. By freeing from these burden, we can have cleaner, less
repetitive code in <em>action</em> functions.</p>
</div>
<p>Language support of <em>automatic currying</em> and <em>infix operator defining</em> make the
above pattern possible. This is why I chose an <a class="reference external" href="https://en.wikipedia.org/wiki/ML_programming_language">ML family</a> language (<em>OCaml</em>)
for this project. Why not <em>haskell</em> then, you asked? As much as I <em>love</em>
<em>haskell</em>, I picked <em>OCaml</em> because there are at least two implementations in
<em>haskell</em> as of today already, besides, <em>OCaml</em> comes with cross-platform
graphics library, so without external dependency, making a GUI is possible,
here is how it looks:</p>
<div class="figure">
<img alt="2048 screenshot" src="../static/img/projects/2048-ml/2048.png" />
<p class="caption">2048 screenshot</p>
</div>
<p>Have time to spare? Get the source from <a class="reference external" href="https://bitbucket.org/pyx/2048-ml/">Bitbucket</a> or <a class="reference external" href="https://github.com/pyx/2048-ml/">Github</a>, and have
fun.</p>
</div>
</div>
Linux Desktop Screenshots 2013https://xrefactor.com/blog/linux-desktop-screenshots-2013.html2013-12-31T01:14:23Z2013-12-31T01:14:23Z
<div class="section" id="linux-desktop-screenshots-2013">
<h1>Linux Desktop Screenshots 2013</h1>
<p>What I used in 2013:</p>
<div class="figure">
<img alt="i3" src="../static/img/blog/ss2013/i3.png" />
<p class="caption">Same old thing, <a class="reference external" href="http://i3wm.org/">i3</a></p>
</div>
</div>
Introducing Simple - an Ena Themehttps://xrefactor.com/blog/introducing-simple-an-ena-theme.html2013-07-07T13:30:19Z2013-07-07T13:30:19Z
<div class="section" id="introducing-simple-an-ena-theme">
<h1>Introducing Simple - an Ena Theme</h1>
<p>Simple is the default theme that comes with <a class="reference external" href="https://xrefactor.com/projects/ena">Ena</a>. The following shows how
different elements are styled by Simple.</p>
<div class="section" id="markup">
<h2>Markup</h2>
<div class="section" id="emphasis">
<h3>Emphasis</h3>
<pre class="code rst literal-block">
This is <span class="ge">*emphasized text*</span>.
</pre>
<p>This is <em>emphasized text</em>.</p>
</div>
<div class="section" id="strong-emphasis">
<h3>Strong Emphasis</h3>
<pre class="code rst literal-block">
This is <span class="gs">**strong text**</span>.
</pre>
<p>This is <strong>strong text</strong>.</p>
</div>
<div class="section" id="inline-code">
<h3>Inline Code</h3>
<pre class="code rst literal-block">
This is <span class="na">:code:</span><span class="nv">`inline code`</span>.
</pre>
<p>This is <code>inline code</code>.</p>
</div>
<div class="section" id="hyperlinks">
<h3>Hyperlinks</h3>
<p>Hyperlinks look like this: <a class="reference external" href="https://en.wikipedia.org/wiki/ReStructuredText">https://en.wikipedia.org/wiki/ReStructuredText</a></p>
</div>
</div>
<div class="section" id="special-admonitions">
<h2>Special Admonitions</h2>
<p>All special admonitions supported by reStructuredText are styled, the
following shows each of them, with corresponding reStructuredText code:</p>
<div class="section" id="note">
<h3>note</h3>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>This is note</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">note</span><span class="p">::</span>
This is note
</pre>
</div>
</div>
<div class="section" id="warning">
<h3>warning</h3>
<div class="admonition warning">
<p class="first admonition-title">Warning</p>
<p>This is warning</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">warning</span><span class="p">::</span>
This is warning
</pre>
</div>
</div>
<div class="section" id="caution">
<h3>caution</h3>
<div class="admonition caution">
<p class="first admonition-title">Caution!</p>
<p>This is caution</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">caution</span><span class="p">::</span>
This is caution
</pre>
</div>
</div>
<div class="section" id="attention">
<h3>attention</h3>
<div class="admonition attention">
<p class="first admonition-title">Attention!</p>
<p>This is attention</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">attention</span><span class="p">::</span>
This is attention
</pre>
</div>
<div class="section" id="danger">
<h4>danger</h4>
<div class="admonition danger">
<p class="first admonition-title">!DANGER!</p>
<p>This is danger</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">danger</span><span class="p">::</span>
This is danger
</pre>
</div>
</div>
</div>
<div class="section" id="error">
<h3>error</h3>
<div class="admonition error">
<p class="first admonition-title">Error</p>
<p>This is error</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">error</span><span class="p">::</span>
This is error
</pre>
</div>
</div>
<div class="section" id="hint">
<h3>hint</h3>
<div class="admonition hint">
<p class="first admonition-title">Hint</p>
<p>This is hint</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">hint</span><span class="p">::</span>
This is hint
</pre>
</div>
</div>
<div class="section" id="important">
<h3>important</h3>
<div class="admonition important">
<p class="first admonition-title">Important</p>
<blockquote>
This is important</blockquote>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">important</span><span class="p">::</span>
This is important
</pre>
</div>
</div>
<div class="section" id="tip">
<h3>tip</h3>
<div class="admonition tip">
<p class="first admonition-title">Tip</p>
<p>This is tip</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">tip</span><span class="p">::</span>
This is tip
</pre>
</div>
</div>
<div class="section" id="admonition">
<h3>admonition</h3>
<div class="admonition admonition-this-is-admonition">
<p class="first admonition-title">This is admonition</p>
<p>Content here.</p>
<pre class="code rst last literal-block">
<span class="p">..</span> <span class="ow">admonition</span><span class="p">::</span> This is admonition
Content here.
</pre>
</div>
</div>
</div>
<div class="section" id="images">
<h2>Images</h2>
<p>Images come in two flavors, <code>image</code> and <code>figure</code>:</p>
<div class="section" id="image">
<h3>image</h3>
<p>In reStructuredText, an <code>image</code> can be defined with <code>image</code> directive:</p>
<pre class="code rst literal-block">
<span class="p">..</span> <span class="ow">image</span><span class="p">::</span> picture.png
</pre>
<p>It looks like this:</p>
<img alt="../static/img/blog/simple/logo.png" src="../static/img/blog/simple/logo.png" />
<p>By default, images will be scaled to full width of the containing elements with
a border in red, if that is not what you want, add <code>:class: as-is</code> to it:</p>
<pre class="code rst literal-block">
<span class="p">..</span> <span class="ow">image</span><span class="p">::</span> picture.png
<span class="nc">:class:</span> <span class="nf">as-is</span>
</pre>
<img alt="../static/img/blog/simple/logo.png" class="as-is" src="../static/img/blog/simple/logo.png" />
</div>
<div class="section" id="figure">
<h3>figure</h3>
<p><code>figure</code> is an image with an optional caption and an optional legend:</p>
<pre class="code rst literal-block">
<span class="p">..</span> <span class="ow">figure</span><span class="p">::</span> picture.png
This is the caption
This is the legend.
</pre>
<div class="figure">
<img alt="../static/img/blog/simple/logo.png" src="../static/img/blog/simple/logo.png" />
<p class="caption">The logo of xrefactor.com</p>
<div class="legend">
I made it with <a class="reference external" href="http://www.gimp.org/">GIMP</a>.</div>
</div>
<p><code>:class: as-is</code> can be used here as well:</p>
<div class="figure">
<img alt="../static/img/blog/simple/logo.png" class="as-is" src="../static/img/blog/simple/logo.png" />
<p class="caption">The logo of xrefactor.com</p>
<div class="legend">
I made it with <a class="reference external" href="http://www.gimp.org/">GIMP</a>.</div>
</div>
</div>
</div>
<div class="section" id="body-elements">
<h2>Body Elements</h2>
<div class="section" id="code">
<h3>code</h3>
<p>Source code blocks can be defined by:</p>
<pre class="code rst literal-block">
<span class="p">..</span> <span class="ow">code</span><span class="p">::</span> <span class="k">c</span>
<span class="cp"></span> <span class="cp">#include</span> <span class="cpf"><stdio.h></span><span class="cp">
</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">*</span><span class="n">argv</span><span class="p">[])</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"%s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="s">"Hello, world!"</span><span class="p">);</span>
<span class="p">(</span><span class="kt">void</span><span class="p">)</span><span class="n">argc</span><span class="p">;</span>
<span class="p">(</span><span class="kt">void</span><span class="p">)</span><span class="n">argv</span><span class="p">;</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre>
</div>
</div>
</div>
Calculating the Maximum, Minimum and Average of Three Numbershttps://xrefactor.com/blog/max-min-average-of-three-numbers.html2013-07-03T20:26:23Z2013-07-03T20:26:23Z
<div class="section" id="calculating-the-maximum-minimum-and-average-of-three-numbers">
<h1>Calculating the Maximum, Minimum and Average of Three Numbers</h1>
<p>The title says it all. As always, I love to answer those <a class="reference external" href="http://tieba.baidu.com/p/2433021887">homework questions</a>
with obfuscated solutions, for that is unsuitable to hand in those solutions.</p>
<p>A simple way to make a solution to entry-level question like this one harder to
understand, is leveraging the fact that functions are first-class in python, so
basically logic and I/O operations, almost everything we need here can be
stuffed inside a single expression, like this:</p>
<pre class="code python literal-block">
<span class="p">[</span><span class="n">f</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">f</span><span class="p">,</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">((</span><span class="nb">max</span><span class="p">,</span> <span class="nb">min</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">s</span><span class="p">))</span><span class="o">/</span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)),</span> <span class="p">([</span><span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">map</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">,</span> <span class="s1">':::'</span><span class="p">)))]</span><span class="o">*</span><span class="mi">3</span><span class="p">))]</span>
</pre>
<p>This is the Python 2 version, for Python 3, substitute <code>raw_input</code> with <code>input</code>.</p>
<p>It works like so:</p>
<pre class="code pycon literal-block">
<span class="p"></span><span class="gp">>>> </span><span class="p">[</span><span class="n">f</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">f</span><span class="p">,</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">((</span><span class="nb">max</span><span class="p">,</span> <span class="nb">min</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">s</span><span class="p">))</span><span class="o">/</span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)),</span> <span class="p">([</span><span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">map</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">,</span> <span class="s1">':::'</span><span class="p">)))]</span><span class="o">*</span><span class="mi">3</span><span class="p">))]</span>
<span class="go">:1
:2
:3
[3, 1, 2.0]</span>
</pre>
<p>For extra fun, I use the number of <code>:</code> (Colon) to control how many
numbers can be accepted, i.e, for six numbers instead of three, change
<code>':::'</code> to <code>'::::::'</code>:</p>
<pre class="code pycon literal-block">
<span class="p"></span><span class="gp">>>> </span><span class="p">[</span><span class="n">f</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">f</span><span class="p">,</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">((</span><span class="nb">max</span><span class="p">,</span> <span class="nb">min</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">s</span><span class="p">))</span><span class="o">/</span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)),</span> <span class="p">([</span><span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">map</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">,</span> <span class="s1">'::::::'</span><span class="p">)))]</span><span class="o">*</span><span class="mi">3</span><span class="p">))]</span>
<span class="go">:12
:34
:56
:78
:90
:42
[90, 12, 52.0]</span>
</pre>
<p>Because of the incompatible differences between Python 2 and Python 3, it can
be a little bit shorter if I am only targeting specific branch of Python.</p>
<p>In Python 2, <code>map</code> returns a <code>list</code>, so explicit <code>list</code>
conversion is not needed:</p>
<pre class="code python literal-block">
<span class="p">[</span><span class="n">f</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">f</span><span class="p">,</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">((</span><span class="nb">max</span><span class="p">,</span> <span class="nb">min</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="nb">sum</span><span class="p">(</span><span class="n">s</span><span class="p">))</span><span class="o">/</span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)),</span> <span class="p">([</span><span class="nb">map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">map</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">,</span> <span class="s1">':::'</span><span class="p">))]</span><span class="o">*</span><span class="mi">3</span><span class="p">))]</span>
</pre>
<p>On the other hand, division operator returns floating-point numbers by default
in Python 3, <code>float</code> function call is no longer necessary:</p>
<pre class="code python literal-block">
<span class="p">[</span><span class="n">f</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">f</span><span class="p">,</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">((</span><span class="nb">max</span><span class="p">,</span> <span class="nb">min</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">s</span><span class="p">:</span> <span class="nb">sum</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="o">/</span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)),</span> <span class="p">([</span><span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">map</span><span class="p">(</span><span class="nb">input</span><span class="p">,</span> <span class="s1">':::'</span><span class="p">)))]</span><span class="o">*</span><span class="mi">3</span><span class="p">))]</span>
</pre>
</div>