atom.xml

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

  <title><![CDATA[CEK.io]]></title>
  <link href="http://cek.io/atom.xml" rel="self"/>
  <link href="http://cek.io/"/>
  <updated>2019-06-27T15:15:02+01:00</updated>
  <id>http://cek.io/</id>
  <author>
    <name><![CDATA[Chris Eaves-Kohlbrenner]]></name>
    <email><![CDATA[c.kohlbrenner@gmail.com]]></email>
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[A (Scheme) Calculator in Clojure]]></title>
    <link href="http://cek.io/blog/2019/06/27/scheme-clojure-calculator/"/>
    <updated>2019-06-27T11:30:00+01:00</updated>
    <id>http://cek.io/blog/2019/06/27/scheme-clojure-calculator</id>
    <content type="html"><![CDATA[<p>I&rsquo;ve been working through <a href="https://mitpress.mit.edu/sites/default/files/sicp/index.html">Structure and Interpretation of Computer Programs (SICP)</a> and watching the <a href="https://archive.org/details/ucberkeley-webcast-PL3E89002AA9B9879E?sort=titleSorter">UC Berkeley CS61A lectures from Brian Harvey</a>. It&rsquo;s great content, so I can understand why he refers to SICP as &ldquo;the best computer science book in the world&rdquo;.</p>

<p>The <a href="https://archive.org/details/ucberkeley_webcast_nzMPF59Ackg">most recent lecture</a> presented a calculator implementation (for a calculator with four functions) in Scheme. This calculator is a simple REPL interpreter: it reads a user input, evaluates it, prints the output, and loops back again.</p>

<p>What follows is a summary of the lecture with my takeaways, including a description of the program (and why it&rsquo;s worth considering), the original Scheme program from the lecture, and my translation of it into Clojure.</p>

<h3>Why look at this example?</h3>


<p>There are two main reasons to look at this:</p>

<ol>
<li> It is an example of processing deep lists (lists of lists of lists)</li>
<li> This is a step towards understanding an actual Scheme interpreter written in Scheme. Unlike an actual Scheme interpreter, this has no variables and no procedures as first-class things. It only has four procedures: <code>+</code>, <code>/</code>, <code>-</code>, and <code>*</code>. But it&rsquo;s Scheme-like in its notation (<code>(+ 6 7)</code>) and does composition of functions as Scheme does.</li>
</ol>


<h3>The 4-function calculator code</h3>


<p>Original Scheme 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>
<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='scheme'><span class='line'><span class="p">(</span><span class="k">define </span><span class="p">(</span><span class="nf">calc</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="nb">display </span><span class="s">&quot;calc: &quot;</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">flush</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">print</span> <span class="p">(</span><span class="nf">calc-eval</span> <span class="p">(</span><span class="nf">read</span><span class="p">)))</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">calc</span><span class="p">))</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="k">define </span><span class="p">(</span><span class="nf">calc-eval</span> <span class="nv">exp</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="k">cond </span><span class="p">((</span><span class="nb">number? </span><span class="nv">exp</span><span class="p">)</span> <span class="nv">exp</span><span class="p">)</span>
</span><span class='line'>        <span class="p">((</span><span class="nb">list? </span><span class="nv">exp</span><span class="p">)</span> <span class="p">(</span><span class="nf">calc-apply</span> <span class="p">(</span><span class="nb">car </span><span class="nv">exp</span><span class="p">)</span> <span class="p">(</span><span class="nb">map </span><span class="nv">calc-eval</span> <span class="p">(</span><span class="nb">cdr </span><span class="nv">exp</span><span class="p">))))</span>
</span><span class='line'>        <span class="p">(</span><span class="k">else </span><span class="p">(</span><span class="nf">error</span> <span class="s">&quot;Calc: bad expression:&quot;</span> <span class="nv">exp</span><span class="p">))))</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="k">define </span><span class="p">(</span><span class="nf">calc-apply</span> <span class="nv">fn</span> <span class="nv">args</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="k">cond </span><span class="p">((</span><span class="nb">eq? </span><span class="nv">fn</span> <span class="ss">&#39;+</span><span class="p">)</span> <span class="p">(</span><span class="nf">accumulate</span> <span class="nv">+</span> <span class="mi">0</span> <span class="nv">args</span><span class="p">))</span>
</span><span class='line'>        <span class="p">((</span><span class="nb">eq? </span><span class="nv">fn</span> <span class="ss">&#39;-</span><span class="p">)</span> <span class="p">(</span><span class="k">cond </span><span class="p">((</span><span class="nb">null? </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nf">error</span> <span class="s">&quot;Calc: no args to -&quot;</span><span class="p">))</span>
</span><span class='line'>                           <span class="p">((</span><span class="nb">= </span><span class="p">(</span><span class="nb">length </span><span class="nv">args</span><span class="p">)</span> <span class="mi">1</span><span class="p">)</span> <span class="p">(</span><span class="nb">- </span><span class="p">(</span><span class="nb">car </span><span class="nv">args</span><span class="p">)))</span>
</span><span class='line'>                           <span class="p">(</span><span class="k">else </span><span class="p">(</span><span class="nb">- </span><span class="p">(</span><span class="nb">car </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nf">accumulate</span> <span class="nv">+</span> <span class="mi">0</span> <span class="p">(</span><span class="nb">cdr </span><span class="nv">args</span><span class="p">))))))</span>
</span><span class='line'>        <span class="p">((</span><span class="nb">eq? </span><span class="nv">fn</span> <span class="ss">&#39;*</span><span class="p">)</span> <span class="p">(</span><span class="nf">accumulate</span> <span class="nv">*</span> <span class="mi">1</span> <span class="nv">args</span><span class="p">))</span>
</span><span class='line'>        <span class="p">((</span><span class="nb">eq? </span><span class="nv">fn</span> <span class="ss">&#39;/</span><span class="p">)</span> <span class="p">(</span><span class="k">cond </span><span class="p">((</span><span class="nb">null? </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nf">error</span> <span class="s">&quot;Calc: no args to /&quot;</span><span class="p">))</span>
</span><span class='line'>                           <span class="p">((</span><span class="nb">= </span><span class="p">(</span><span class="nb">length </span><span class="nv">args</span><span class="p">)</span> <span class="mi">1</span><span class="p">)</span> <span class="p">(</span><span class="nb">/ </span><span class="p">(</span><span class="nb">car </span><span class="nv">args</span><span class="p">)))</span>
</span><span class='line'>                           <span class="p">(</span><span class="k">else </span><span class="p">(</span><span class="nb">/ </span><span class="p">(</span><span class="nb">car </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nf">accumulate</span> <span class="nv">*</span> <span class="mi">1</span> <span class="p">(</span><span class="nb">cdr </span><span class="nv">args</span><span class="p">))))))</span>
</span><span class='line'>        <span class="p">(</span><span class="k">else </span><span class="p">(</span><span class="nf">error</span> <span class="s">&quot;Calc: bad operator:&quot;</span> <span class="nv">fn</span><span class="p">))))</span>
</span></code></pre></td></tr></table></div></figure>


<p>And my translation into Clojure:</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>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">calc-apply</span> <span class="p">[</span><span class="k">fn </span><span class="nv">args</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">cond</span>
</span><span class='line'>    <span class="p">(</span><span class="nb">= </span><span class="k">fn </span><span class="ss">&#39;+</span><span class="p">)</span> <span class="p">(</span><span class="nb">reduce + </span><span class="mi">0</span> <span class="nv">args</span><span class="p">)</span>
</span><span class='line'>    <span class="p">(</span><span class="nb">= </span><span class="k">fn </span><span class="ss">&#39;-</span><span class="p">)</span> <span class="p">(</span><span class="nf">cond</span>
</span><span class='line'>                <span class="p">(</span><span class="nb">nil? </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nf">throw</span> <span class="p">(</span><span class="nf">Exception.</span> <span class="s">&quot;Calc: no args to -&quot;</span><span class="p">))</span>
</span><span class='line'>                <span class="p">(</span><span class="nb">= </span><span class="p">(</span><span class="nb">count </span><span class="nv">args</span><span class="p">)</span> <span class="mi">1</span><span class="p">)</span> <span class="p">(</span><span class="nb">- </span><span class="p">(</span><span class="nb">first </span><span class="nv">args</span><span class="p">))</span>
</span><span class='line'>                <span class="ss">:else</span> <span class="p">(</span><span class="nb">- </span><span class="p">(</span><span class="nb">first </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nb">reduce + </span><span class="mi">0</span> <span class="p">(</span><span class="nb">rest </span><span class="nv">args</span><span class="p">))))</span>
</span><span class='line'>    <span class="p">(</span><span class="nb">= </span><span class="k">fn </span><span class="ss">&#39;*</span><span class="p">)</span> <span class="p">(</span><span class="nb">reduce * </span><span class="mi">1</span> <span class="nv">args</span><span class="p">)</span>
</span><span class='line'>    <span class="p">(</span><span class="nb">= </span><span class="k">fn </span><span class="ss">&#39;/</span><span class="p">)</span> <span class="p">(</span><span class="nf">cond</span>
</span><span class='line'>                <span class="p">(</span><span class="nb">nil? </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nf">throw</span> <span class="p">(</span><span class="nf">Exception.</span> <span class="s">&quot;Calc: no args to /&quot;</span><span class="p">))</span>
</span><span class='line'>                <span class="p">(</span><span class="nb">= </span><span class="p">(</span><span class="nb">count </span><span class="nv">args</span><span class="p">)</span> <span class="mi">1</span><span class="p">)</span> <span class="p">(</span><span class="nb">/ </span><span class="p">(</span><span class="nb">first </span><span class="nv">args</span><span class="p">))</span>
</span><span class='line'>                <span class="ss">:else</span> <span class="p">(</span><span class="nb">/ </span><span class="p">(</span><span class="nb">first </span><span class="nv">args</span><span class="p">)</span> <span class="p">(</span><span class="nb">reduce + </span><span class="mi">0</span> <span class="p">(</span><span class="nb">rest </span><span class="nv">args</span><span class="p">))))</span>
</span><span class='line'>    <span class="ss">:else</span> <span class="p">(</span><span class="nf">throw</span> <span class="p">(</span><span class="nf">Exception.</span> <span class="p">(</span><span class="nb">str </span><span class="s">&quot;Calc: bad operator:&quot;</span> <span class="nv">fn</span><span class="p">)))))</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">calc-eval</span> <span class="p">[</span><span class="nv">exp</span><span class="p">]</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">cond</span>
</span><span class='line'>    <span class="p">(</span><span class="nf">number?</span> <span class="nv">exp</span><span class="p">)</span> <span class="nv">exp</span>
</span><span class='line'>    <span class="p">(</span><span class="nf">list?</span> <span class="nv">exp</span><span class="p">)</span> <span class="p">(</span><span class="nf">calc-apply</span> <span class="p">(</span><span class="nb">first </span><span class="nv">exp</span><span class="p">)</span>
</span><span class='line'>                            <span class="p">(</span><span class="nb">map </span><span class="nv">calc-eval</span> <span class="p">(</span><span class="nb">rest </span><span class="nv">exp</span><span class="p">)))</span>
</span><span class='line'>    <span class="ss">:else</span> <span class="p">(</span><span class="nf">throw</span> <span class="p">(</span><span class="nf">Exception.</span> <span class="p">(</span><span class="nb">str </span><span class="s">&quot;Calc: bad expression:&quot;</span> <span class="nv">exp</span><span class="p">)))))</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="kd">defn </span><span class="nv">calc</span> <span class="p">[]</span>
</span><span class='line'>  <span class="p">(</span><span class="nb">println </span><span class="s">&quot;calc: &quot;</span><span class="p">)</span>
</span><span class='line'>  <span class="p">(</span><span class="nb">println </span><span class="p">(</span><span class="nf">calc-eval</span> <span class="p">(</span><span class="nf">read</span><span class="p">)))</span>
</span><span class='line'>  <span class="p">(</span><span class="nf">calc</span><span class="p">))</span>
</span></code></pre></td></tr></table></div></figure>




<h3>Dealing with Deep Lists</h3>


<p>The key to handling deep lists can be seen in <code>(map calc-eval (cdr exp))</code>. It is sort of a recursive call, but not a exactly a recursive call, because there&rsquo;s no open parenthesis in front of <code>calc-eval</code>. Instead, <code>calc-eval</code> is an argument to <code>map</code>; <code>map</code> will typically call <code>calc-eval</code> more than once (for each sub-expression). So it&rsquo;s not just a simple recursive call, but a multi-way recursive call, which is the secret of dealing with deep lists.</p>

<p>For deep lists, we make a recursive call for each element of the top level list, and then for each element of sub-lists, and so on all the way down. The base case is an empty list (or when the expression isn&rsquo;t a list).</p>

<h3>Interpreters and Types of Expressions</h3>


<p>There are three pieces to an interpreter (and this goes for any interpreter, not just Scheme or Clojure):</p>

<ol>
<li>The read-eval-print loop (REPL). It&rsquo;s a loop because the last thing in it is a call to itself, so it runs forever. In the example, <code>read</code> turns things in parentheses into pairs. <code>calc-eval</code> takes an expression as its argument and returns (and prints) the value of that expression.</li>
<li><code>(eval exp)</code> returns the value of the expression</li>
<li><code>(apply function arglist)</code> returns the value returned by the function. This is where the example is different from a full interpreter: the actual Scheme interpreter handles first-class procedures, whereas this calculator example depends on the <em>name</em> of the function (must be one of <code>+</code>, <code>/</code>, <code>-</code>, and <code>*</code>.</li>
</ol>


<p>In Scheme, there are basically four types of expressions:</p>

<ul>
<li><strong>Self-evaluating expressions</strong> (primitives) like numbers or booleans &mdash; these are used in the calculator</li>
<li><strong>Variables</strong> &mdash; these are <strong>not</strong> supported in the calculator</li>
<li><strong>Function calls</strong> &mdash; these are used in the calculator</li>
<li><strong>Special forms</strong> &mdash; these are <strong>not</strong> supported in the calculator. A full interpreter would include special forms, but this introduces a lot of complexity which is ignored in the calculator example.</li>
</ul>


<p>In an interpreter, an evaluator&rsquo;s job is to take the stuff that is typed in and figure out what it means. This requires figuring out what the notation means. Scheme and Clojure (or any Lisp) make this easier, because a complete expression is one list; the language was designed in order to be able to evaluate its own programs. Compare this to Java, for example, where there are many different notations that are not uniform, so what you can put in one context is different than another context.</p>

<p>Lispians say &ldquo;at the heart of every programming language there&rsquo;s a lisp interpreter trying to get out&rdquo;, because you have to evaluate expressions that are procedure calls. Syntax doesn&rsquo;t get in the way.</p>

<p>A few differences between a full interpreter and this example can be seen in the following:</p>

<ul>
<li><strong><code>calc-eval</code></strong>: we will not see a recursive call for <code>(car exp)</code> in <code>calc-eval</code>; <code>(car exp)</code> has to be one of the 4 math symbols, but in a real Scheme interpreter it could be a symbol that&rsquo;s the name of a procedure, or it could be a lambda or procedure call or any number of other things to provide the function (so it would need to be evaluated).</li>
<li><strong><code>calc-apply</code></strong>: this function takes <code>fn</code> and <code>args</code> as its arguments, where <code>args</code> is always a list. This is not just a simplification, but an actual difference from a full interpreter: we don&rsquo;t have procedures as first-class values, so fn argument is a <em>symbol</em>, not the procedure itself. This means that the calculator cannot handle all procedures (like <code>sqrt</code>, etc.)</li>
</ul>


<p>There are a number of properties of a programming language that determine what it is to be a program in that language. For example, Scheme has first-class procedures, applicative order, variables. All of these properties manifest themselves in the interpreter; we can look at the interpreter and ask &ldquo;how would I change this interpreter if I wanted Scheme, but with normal order instead of applicative order?&rdquo; In that case, don&rsquo;t call <code>(map calc-eval (cdr exp))</code>, but just use <code>(cdr exp)</code>. Then we&rsquo;d be giving apply actual argument expressions rather than argument values.</p>

<h3>Syntax and Semantics</h3>


<p><em>Syntax</em> is the technical term for the form of a program, what the program looks like. The Scheme function syntax is <code>(procedure arg arg arg)</code>. <em>Semantics</em> is what that thing means. For example, <code>(procedure arg arg arg)</code> means &ldquo;call that procedure with these argument values after you&rsquo;ve recursively evaluated the argument expressions&rdquo;. There are differences across languages, but we see more or less the same kinds of things in the semantics&mdash;conditionals, loops, call functions, define variables&mdash;while syntax can be very different across languages.</p>

<p>An important point about the calculator: we are actually dealing with two different programming languages. <em>The calculator is a program written in Scheme, but the language that the calculator implements is a programming language that isn&rsquo;t Scheme</em>. For example, there are no variables in this calculator programming language. When Scheme interpreters are written in Scheme, there are also two languages involved (and it&rsquo;s more difficult to see the differences than Scheme vs. calculator language).</p>

<p>Notice that <code>eval</code> lives in both the syntax and semantics worlds. When it takes an expression (syntax) and returns a value, it turns syntax into semantics by turning the form into something meaningful. Meanwhile <code>apply</code> doesn&rsquo;t know anything about syntax. It takes a procedure and argument values, so it&rsquo;s entirely about semantics.</p>

<h3>An Aside on Functional Programming</h3>


<p>The <code>read</code> and <code>print</code> functions are primitive procedures that are <em>not</em> functional. <code>read</code> is not functional because, every time you call it with the same arguments, you get a different answer. <code>print</code> is not functional because it changes the state of the world. Functions just compute and return values. Even though Scheme is a functional programming language, the Scheme interpreter itself is not an entirely functional program. Most of it (<code>eval</code> and <code>apply</code>) is functional, since it just takes arguments and returns values.</p>

<h3>Some Clojure/Scheme Observations</h3>


<p>Clearly Scheme and Clojure are both Lisps. It&rsquo;s nice to see that the Clojure implementation is as consise as Scheme (it&rsquo;s four more lines, but that could be eliminated if we didn&rsquo;t put the four <code>cond</code>s on their own line). There are a few syntax differences (Clojure <code>reduce</code> instead of Scheme <code>accumulate</code>, <code>read-line</code> instead of <code>read</code>), but the semantics are identical.</p>

<p>One final syntax difference: In Scheme (and Common Lisp and most other Lisp dialects), <code>cons</code> is a primitive data structure made up of a pair. In Clojure, this is not the case. We can see the <code>cons</code> in the Scheme example when we use <code>car</code> (to access the first element) and <code>cdr</code> (to access the rest). Clojure <em>does</em> have a <code>cons</code> function, but it works differently:</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='clojure'><span class='line'><span class="p">(</span><span class="nb">cons </span><span class="mi">1</span> <span class="mi">2</span><span class="p">)</span> <span class="c1">; IllegalArgumentException Don&#39;t know how to create ISeq from: java.lang.Long</span>
</span><span class='line'>
</span><span class='line'><span class="p">(</span><span class="nb">cons </span><span class="mi">1</span> <span class="o">&#39;</span><span class="p">(</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">))</span> <span class="c1">; (1 2 3 4)</span>
</span><span class='line'>
</span><span class='line'><span class="c1">; this is not a list, but a Cons</span>
</span><span class='line'><span class="p">(</span><span class="nf">list?</span> <span class="p">(</span><span class="nb">cons </span><span class="mi">1</span> <span class="o">&#39;</span><span class="p">(</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">)))</span> <span class="c1">; false</span>
</span><span class='line'><span class="p">(</span><span class="nf">type</span> <span class="p">(</span><span class="nb">cons </span><span class="mi">1</span> <span class="o">&#39;</span><span class="p">(</span><span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">)))</span> <span class="c1">; clojure.lang.Cons</span>
</span></code></pre></td></tr></table></div></figure>


<p>This is really a subject for <a href="https://stackoverflow.com/questions/34347985/clojure-no-cons-cells">further</a> <a href="https://stackoverflow.com/questions/5741111/help-explaining-how-cons-in-scheme-work">reading</a>, but suffice it to say that Clojure is a Lisp with some <a href="https://clojure.org/reference/lisps">differences from other Lisps</a>, including the fact that &ldquo;<code>cons</code>, <code>first</code> and <code>rest</code> manipulate sequence abstractions, not concrete cons cells&rdquo;.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[A Clojure Introduction to Binary and Bitwise Operators]]></title>
    <link href="http://cek.io/blog/2017/08/17/clojure-introduction-binary-bitwise/"/>
    <updated>2017-08-17T23:00:00+01:00</updated>
    <id>http://cek.io/blog/2017/08/17/clojure-introduction-binary-bitwise</id>
    <content type="html"><![CDATA[<p>I&rsquo;ve been working in Clojure and ClojureScript lately. A few months back, I came across <a href="http://realworldclojure.com/one-weird-trick/">this one weird trick to master Clojure</a>. <em>TL;DR</em>: it recommends reading the API docs, fully, top to bottom.</p>

<blockquote><p>I’m not even joking! Go to this URL http://clojure.github.io/clojure/clojure.core-api.html and start reading from top to bottom. If you did not read through that page, you may not know about amap. If you stopped reading before you get to ‘f’ you wouldn’t know about frequencies. However, if you read all the way through, you will be rewarded with knowledge about vary-meta.</p><footer><strong>&#8220;One Weird Trick To Become a Clojure Expert&#8221;</strong> <cite><a href='http://realworldclojure.com/one-weird-trick/'>realworldclojure.com/&hellip;</a></cite></footer></blockquote>


<p>In the process of doing this, I was struck by all the <code>bit-</code> functions &mdash; of the ~600 vars and functions in <code>clojure.core</code>, there are 12 specifically for bitwise operations.</p>

<h3>Binary Fundamentals</h3>


<p>A quick overview on binary:</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='clojure'><span class='line'><span class="c1">;; base-10 (decimal) to base-2 (binary). from right-to-left, binary columns are 1, 2, 4, 8, 16, ... (derived from 2^0, 2^1, 2^2, 2^3, 2^4, ...).</span>
</span><span class='line'><span class="c1">;;</span>
</span><span class='line'><span class="c1">;; base-10        base-2                              math spelled out</span>
</span><span class='line'><span class="c1">;;    0                0            0   =  (0 * 1)</span>
</span><span class='line'><span class="c1">;;    1                1            1   =  (1 * 1)</span>
</span><span class='line'><span class="c1">;;    2               10            2   =  (1 * 2) + (0 * 1)</span>
</span><span class='line'><span class="c1">;;    3               11            3   =  (1 * 2) + (1 * 1)</span>
</span><span class='line'><span class="c1">;;    4              100            4   =  (1 * 4) + (0 * 2) + (0 * 1)</span>
</span><span class='line'><span class="c1">;;    5              101            5   =  (1 * 4) + (0 * 2) + (1 * 1)</span>
</span><span class='line'><span class="c1">;;    6              110            6   =  (1 * 4) + (1 * 2) + (0 * 1)</span>
</span><span class='line'><span class="c1">;;    7              111            7   =  (1 * 4) + (1 * 2) + (1 * 1)</span>
</span><span class='line'><span class="c1">;;    8             1000            8   =  (1 * 8) + (0 * 4) + (0 * 2) + (0 * 1)</span>
</span><span class='line'><span class="c1">;;    9             1001            9   =  (1 * 8) + (0 * 4) + (0 * 2) + (1 * 1)</span>
</span><span class='line'><span class="c1">;;   10             1010            10  =  (1 * 8) + (0 * 4) + (1 * 2) + (0 * 1)</span>
</span><span class='line'><span class="c1">;;   11             1011            11  =  (1 * 8) + (0 * 4) + (1 * 2) + (1 * 1)</span>
</span><span class='line'><span class="c1">;;   12             1100            12  =  (1 * 8) + (1 * 4) + (0 * 2) + (0 * 1)</span>
</span><span class='line'><span class="c1">;;   13             1101            13  =  (1 * 8) + (1 * 4) + (0 * 2) + (1 * 1)</span>
</span><span class='line'><span class="c1">;;   14             1110            14  =  (1 * 8) + (1 * 4) + (1 * 2) + (0 * 1)</span>
</span><span class='line'><span class="c1">;;   15             1111            15  =  (1 * 8) + (1 * 4) + (1 * 2) + (1 * 1)</span>
</span><span class='line'><span class="c1">;;   16            10000            16  = (1 * 16) + (0 * 8) + (0 * 4) + (0 * 2) + (0 * 1)</span>
</span><span class='line'>
</span><span class='line'><span class="c1">;; test in a repl</span>
</span><span class='line'><span class="c1">;; use `2r` to convert binary integer to decimal</span>
</span><span class='line'><span class="c1">;; use `java.lang.Integer/toBinaryString` to convert decimal integer to binary</span>
</span><span class='line'><span class="nv">$</span> <span class="nv">lein</span> <span class="nv">repl</span>
</span><span class='line'>
</span><span class='line'><span class="c1">;; compare 11 (base-2) to 3 (base-10)</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="mi">2</span><span class="nv">r11</span>
</span><span class='line'><span class="mi">3</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">Integer/toBinaryString</span> <span class="mi">3</span><span class="p">)</span>
</span><span class='line'><span class="s">&quot;11&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="c1">;; compare 1101 (base-2) to 13 (base-10)</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="mi">2</span><span class="nv">r1101</span>
</span><span class='line'><span class="mi">13</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">Integer/toBinaryString</span> <span class="mi">13</span><span class="p">)</span>
</span><span class='line'><span class="s">&quot;1101&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="c1">;; side note: 2r means binary, can&#39;t take values besides 0 or 1</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="mi">2</span><span class="nv">r2</span>
</span><span class='line'><span class="nv">NumberFormatException</span> <span class="nv">For</span> <span class="nv">input</span> <span class="nv">string</span><span class="err">:</span> <span class="s">&quot;2&quot;</span>  <span class="nv">java.lang.NumberFormatException.forInputString</span> <span class="p">(</span><span class="nf">NumberFormatException.java</span><span class="ss">:65</span><span class="p">)</span>
</span></code></pre></td></tr></table></div></figure>


<p>Some things to note:</p>

<ul>
<li>We can disregard leading zeros in binary, so binary <code>0010</code> and binary <code>10</code> both represent decimal <code>2</code>.</li>
<li>Each position is one bit (&ldquo;bit&rdquo; means &ldquo;<em>b</em>inary dig<em>it</em>&rdquo;). So <code>1111</code> is a 4-bit integer (so we can represent up to 15 different values). A 32-bit integer maxes at <code>11111111111111111111111111111111</code> (so we can represent up to 4,294,967,295 values). We&rsquo;ll see that we don&rsquo;t always use every position counting up from 0 (the left-most position will be used to determine positive/negative).</li>
<li>This blog post uses <code>2r....</code> and <code>Integer/toBinaryString</code> to convert between binary and decimal. Other functions and formatters are discussed <a href="https://stackoverflow.com/questions/21448788/printing-the-binary-value-of-a-number-in-clojure">here</a>.</li>
</ul>


<h3>Bitwise Operators</h3>


<p>This brings us to the bitwise operators. There are 12 in <code>clojure.core</code> (all visible in <a href="https://github.com/clojure/clojure/blob/master/src/clj/clojure/core.clj">the source</a>):</p>

<p><code>bit-and</code> &ndash; Bitwise and</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>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="c1">;; `bit-and` does a logical AND across columns</span>
</span><span class='line'><span class="c1">;; 1010     ; 10</span>
</span><span class='line'><span class="c1">;; 1001     ; 9</span>
</span><span class='line'><span class="c1">;; ----</span>
</span><span class='line'><span class="c1">;; 1000     ; 8   ; by column: 1 AND 1   =&gt;   1</span>
</span><span class='line'><span class="c1">;;                             0 AND 0   =&gt;   0</span>
</span><span class='line'><span class="c1">;;                             1 AND 0   =&gt;   0</span>
</span><span class='line'><span class="c1">;;                             0 AND 1   =&gt;   0</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-and </span><span class="mi">10</span> <span class="mi">9</span><span class="p">)</span>
</span><span class='line'><span class="mi">8</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-and </span><span class="mi">2</span><span class="nv">r1010</span> <span class="mi">2</span><span class="nv">r1001</span><span class="p">)</span>
</span><span class='line'><span class="mi">8</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-or</code> &ndash; Bitwise or</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>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="c1">;; `bit-or` does a logical OR across columns</span>
</span><span class='line'><span class="c1">;; 1010     ; 10</span>
</span><span class='line'><span class="c1">;; 1001     ; 9</span>
</span><span class='line'><span class="c1">;; ----</span>
</span><span class='line'><span class="c1">;; 1011     ; 11  ; by column: 1 OR 1   =&gt;   1</span>
</span><span class='line'><span class="c1">;;                             0 OR 0   =&gt;   0</span>
</span><span class='line'><span class="c1">;;                             1 OR 0   =&gt;   1</span>
</span><span class='line'><span class="c1">;;                             0 OR 1   =&gt;   1</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-or </span><span class="mi">10</span> <span class="mi">9</span><span class="p">)</span>
</span><span class='line'><span class="mi">11</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-or </span><span class="mi">2</span><span class="nv">r1010</span> <span class="mi">2</span><span class="nv">r1001</span><span class="p">)</span>
</span><span class='line'><span class="mi">11</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-xor</code> &ndash; Bitwise exclusive or</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>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="c1">;; `bit-xor` does an exclusive OR across columns (true when the two values are different)</span>
</span><span class='line'><span class="c1">;; 1010     ; 10</span>
</span><span class='line'><span class="c1">;; 1001     ; 9</span>
</span><span class='line'><span class="c1">;; ----</span>
</span><span class='line'><span class="c1">;; 0011     ; 11  ; by column: 1 XOR 1   =&gt;   0</span>
</span><span class='line'><span class="c1">;;                             0 XOR 0   =&gt;   0</span>
</span><span class='line'><span class="c1">;;                             1 XOR 0   =&gt;   1</span>
</span><span class='line'><span class="c1">;;                             0 XOR 1   =&gt;   1</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-xor </span><span class="mi">10</span> <span class="mi">9</span><span class="p">)</span>
</span><span class='line'><span class="mi">3</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-xor </span><span class="mi">2</span><span class="nv">r1010</span> <span class="mi">2</span><span class="nv">r1001</span><span class="p">)</span>
</span><span class='line'><span class="mi">3</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-not</code> &ndash; Bitwise complement</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='clojure'><span class='line'><span class="c1">;; `bit-not` does a complement, negating each position so each 0 becomes 1 and each 1 becomes 0</span>
</span><span class='line'><span class="c1">;; this reads 1010 as the 32-bit integer     00000000000000000000000000001010 (including leading 0s),</span>
</span><span class='line'><span class="c1">;; which, when negated/complemented, becomes 11111111111111111111111111110101 (represents decimal -11).</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-not </span><span class="mi">2</span><span class="nv">r1010</span><span class="p">)</span>
</span><span class='line'><span class="mi">-11</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-and-not</code> &ndash; Bitwise and with complement</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>
</pre></td><td class='code'><pre><code class='clojure'><span class='line'><span class="c1">;; `bit-and-not` ANDs the first integer with the complement of the second</span>
</span><span class='line'><span class="c1">;; (bit-and-not 2r1010 2r1001)</span>
</span><span class='line'><span class="c1">;; (bit-and 2r1010 (bit-not 2r1001))</span>
</span><span class='line'><span class="c1">;; (bit-and 2r1010 2r0110)    =&gt;    0010    =&gt; 2</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-and-not</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">2</span><span class="nv">r1001</span><span class="p">)</span>
</span><span class='line'><span class="mi">2</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-and </span><span class="mi">2</span><span class="nv">r1010</span> <span class="p">(</span><span class="nb">bit-not </span><span class="mi">2</span><span class="nv">r1001</span><span class="p">))</span>
</span><span class='line'><span class="mi">2</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-clear</code> &ndash; Clear bit at index n</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='clojure'><span class='line'><span class="c1">;; `bit-clear` sets the bit to 0 at a given index (0-based, right to left)</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-clear</span> <span class="mi">2</span><span class="nv">r1011</span> <span class="mi">0</span><span class="p">)</span>   <span class="c1">;; clears the 0th bit from right</span>
</span><span class='line'><span class="mi">10</span>  <span class="c1">;; 2r1010</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-clear</span> <span class="mi">2</span><span class="nv">r1011</span> <span class="mi">1</span><span class="p">)</span>   <span class="c1">;; clears the 1st bit from right</span>
</span><span class='line'><span class="mi">9</span>   <span class="c1">;; 2r1001</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-clear</span> <span class="mi">2</span><span class="nv">r1011</span> <span class="mi">2</span><span class="p">)</span>   <span class="c1">;; clears the 2nd bit from right</span>
</span><span class='line'><span class="mi">11</span>  <span class="c1">;; 2r1011</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-clear</span> <span class="mi">2</span><span class="nv">r1011</span> <span class="mi">3</span><span class="p">)</span>   <span class="c1">;; clears the 3rd bit from right</span>
</span><span class='line'><span class="mi">3</span>   <span class="c1">;; 2r0011</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-flip</code> &ndash; Flip bit at index n</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='clojure'><span class='line'><span class="c1">;; `bit-flip` flips the bit (changes 0 to 1 or 1 to 0)at a given index</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-flip</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">0</span><span class="p">)</span>   <span class="c1">;; flips the 0th bit from right</span>
</span><span class='line'><span class="mi">11</span>  <span class="c1">;; 2r1011</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-flip</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">1</span><span class="p">)</span>   <span class="c1">;; flips the 1st bit from right</span>
</span><span class='line'><span class="mi">8</span>   <span class="c1">;; 2r1000</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-flip</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">2</span><span class="p">)</span>   <span class="c1">;; flips the 2nd bit from right</span>
</span><span class='line'><span class="mi">14</span>  <span class="c1">;; 2r1110</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-flip</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">3</span><span class="p">)</span>   <span class="c1">;; flips the 3rd bit from right</span>
</span><span class='line'><span class="mi">2</span>   <span class="c1">;; 2r0010</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-set</code> &ndash; Set bit at index n</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='clojure'><span class='line'><span class="c1">;; `bit-set` sets the bit to 1 at a given index</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-set</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">2</span><span class="p">)</span>   <span class="c1">;; sets the 2nd bit from right to 1</span>
</span><span class='line'><span class="mi">14</span>  <span class="c1">;; 2r1110</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-test</code> &ndash; Test bit at index n</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='clojure'><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-test</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">0</span><span class="p">)</span>   <span class="c1">;; checks if the 0th bit from right is 1</span>
</span><span class='line'><span class="nv">false</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">bit-test</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">1</span><span class="p">)</span>   <span class="c1">;; checks if the 1st bit from right is 1</span>
</span><span class='line'><span class="nv">true</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-shift-left</code> &ndash; Bitwise shift left</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='clojure'><span class='line'><span class="c1">;; `bit-shift-left` shifts the entire integer left, filling in empty spaces as 0</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-shift-left </span><span class="mi">2</span><span class="nv">r1010</span> <span class="mi">1</span><span class="p">)</span> <span class="c1">;; shifts the integer left 1 position (filling empty position with 0)</span>
</span><span class='line'><span class="mi">20</span>  <span class="c1">; 2r10100</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-shift-left </span><span class="mi">2</span><span class="nv">r1011</span> <span class="mi">3</span><span class="p">)</span> <span class="c1">;; shifts the integer left 3 positions (filling empty positions with 0)</span>
</span><span class='line'><span class="mi">88</span> <span class="c1">; 2r1011000</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>bit-shift-right</code> &ndash; Bitwise shift right</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='clojure'><span class='line'><span class="c1">;; `bit-shift-right` shifts the entire integer right, clearing positions &lt; 0</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-shift-right </span><span class="mi">2</span><span class="nv">r1010</span> <span class="mi">1</span><span class="p">)</span> <span class="c1">;; shifts the integer right 1 position</span>
</span><span class='line'><span class="mi">5</span>  <span class="c1">; 2r101</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-shift-right </span><span class="mi">2</span><span class="nv">r1011</span> <span class="mi">3</span><span class="p">)</span> <span class="c1">;; shifts the integer right 3 positions</span>
</span><span class='line'><span class="mi">1</span> <span class="c1">; 2r1</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>unsigned-bit-shift-right</code> &ndash; Bitwise shift right, without sign-extension</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='clojure'><span class='line'><span class="c1">;; `unsigned-bit-shift-right` does a `bit-shift-right` (so same behavior for small integers). its</span>
</span><span class='line'><span class="c1">;; difference is that all the other operations are for 32-bit signed integers, whereas this accepts</span>
</span><span class='line'><span class="c1">;; unsigned (no negative values, only positive) integers</span>
</span><span class='line'>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">unsigned-bit-shift-right</span> <span class="mi">2</span><span class="nv">r1010</span> <span class="mi">1</span><span class="p">)</span>
</span><span class='line'><span class="mi">5</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nb">bit-shift-right </span><span class="mi">2</span><span class="nv">r1010</span> <span class="mi">1</span><span class="p">)</span>
</span><span class='line'><span class="mi">5</span>
</span></code></pre></td></tr></table></div></figure>




<h3>Negative Binary (Signed and Unsigned Integers)</h3>




<h5>Sign-Magnitude Notation</h5>




<div style="float:right; display:flex; flex-direction:column; margin-left: 30px;">
  <img src="http://cek.io/images/bits/positive-signed-int.gif" />
  <img src="http://cek.io/images/bits/negative-signed-int.gif" />
  <span style="font-size:0.75em;">Source: <a href="http://www.electronics-tutorials.ws/binary/signed-binary-numbers.html">&#8220;Signed Binary Numbers&#8221;</a></span>
</div>


<p>Negative numbers can be represented using signed integers, where the left-most position represents whether the integer is positive or negative. In one implementation (sign-magnitude notation), the left-most bit is the sign, and the remaining bits are the value.</p>

<p>This means that in an <code>n</code>-bit integer (e.g., 4-bit), the left-most bit signifies positive/negative, so the remaining <code>n-1</code> (3) bits can hold the actual value. There are 16 possible values for a 4-bit integer (<code>0000</code> to <code>1111</code>), meaning that a signed 4-bit integer can go from -7 to +7 (it is 16 possible values because we can represent both <code>-0</code> and <code>+0</code>, as binary <code>1000</code> and <code>0000</code>).</p>

<h5>Two&#8217;s Complement</h5>


<p>Two&rsquo;s Complement is a slightly more complicated scheme for signed integers (though not overly so), and the one more commonly used. A leading <code>1</code> still signifies a negative integer. The difference is that it&rsquo;s not simply sign (1st bit) and magnitude (remaining bits), because the magnitude is determined using the <em>complement</em> (hence the name).</p>

<p>Up until now, all the code samples have been <em>unsigned</em> integers, which is why all the values are positive (and all the examples with a leading 1 haven&rsquo;t been negative). Assuming 8-bit signed integers, we interpret things as follows:</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='clojure'><span class='line'><span class="mi">00001010</span>    <span class="c1">;;  10</span>
</span><span class='line'>
</span><span class='line'><span class="c1">;; to get -10, complement and add 1</span>
</span><span class='line'><span class="mi">11110101</span>    <span class="c1">;; first complement</span>
</span><span class='line'><span class="mi">11110110</span>    <span class="c1">;; then add 1</span>
</span><span class='line'>
</span><span class='line'><span class="c1">;; so 11110110 is the signed 8-bit representation of -10</span>
</span></code></pre></td></tr></table></div></figure>




<h5>Idiosyncracies between signed and unsigned integers</h5>


<p>I alluded to this in the previous section: all the code samples have been <em>unsigned</em> integers. We&rsquo;ve been exploring conversions between decimal and binary using Clojure&rsquo;s radix-based entry format (e.g., <code>2r1010</code>), <a href="https://clojure.org/reference/reader#_literals">which uses Java Longs</a> and Java&rsquo;s <code>Integer/toBinaryString</code>, which returns strings.</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='clojure'><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">type</span> <span class="mi">2</span><span class="nv">r1010</span><span class="p">)</span>
</span><span class='line'><span class="nv">java.lang.Long</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">type</span> <span class="p">(</span><span class="nf">Integer/toBinaryString</span> <span class="mi">10</span><span class="p">))</span>
</span><span class='line'><span class="nv">java.lang.String</span>
</span></code></pre></td></tr></table></div></figure>


<p>This means there appear to be inconsistencies when dealing with signed integers:</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='clojure'><span class='line'><span class="nv">user=&gt;</span> <span class="p">(</span><span class="nf">Integer/toBinaryString</span> <span class="mi">-1</span><span class="p">)</span>
</span><span class='line'><span class="s">&quot;11111111111111111111111111111111&quot;</span>
</span><span class='line'><span class="nv">user=&gt;</span> <span class="mi">2</span><span class="nv">r11111111111111111111111111111111</span>
</span><span class='line'><span class="mi">4294967295</span>  <span class="c1">;; might expect -1</span>
</span></code></pre></td></tr></table></div></figure>


<p>I say there <em>appear</em> to be inconsistencies, because this is the expected result of using Long. A full discussion gets into the intricacies of language design and primitives, as exemplified by threads like <a href="https://groups.google.com/forum/#!topic/clojure/7-hARL5c1lI">this</a> and <a href="https://groups.google.com/forum/#!topic/clojure/yMhQWVyRzBE%5B1-25%5D">this</a>.</p>

<p><h3>Resources</h5></p>

<ul>
<li><a href="http://upshots.org/actionscript/basics-of-binary-and-bitwise-operations">Non-Clojure overview of bitwise operations</a></li>
<li><a href="http://www.electronics-tutorials.ws/binary/signed-binary-numbers.html">Explanation of Signed Binary Integers</a></li>
<li><a href="https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html">Summary of Two&rsquo;s Complement</a></li>
<li><a href="http://blog.mishkovskyi.net/posts/2015/Oct/29/clojure-numbers-despair">One person&rsquo;s thoughts on Clojure numbers</a> (be sure to read Alex Miller&rsquo;s comment at the end)</li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Ramda.js Array Sorting (With Tiebreakers) Using R.comparator, Variadic R.either, and R.reduce]]></title>
    <link href="http://cek.io/blog/2016/10/29/ramda-sort-tiebreakers-comparators-either/"/>
    <updated>2016-10-29T17:50:14+01:00</updated>
    <id>http://cek.io/blog/2016/10/29/ramda-sort-tiebreakers-comparators-either</id>
    <content type="html"><![CDATA[<p>A recent exercise in data processing with <a href="http://ramdajs.com/">Ramda.js</a>: I wanted to sort an array of objects by their key/value pairs. More specifically, I wanted to sort an array that looked 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>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="p">[</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="s2">&quot;code&quot;</span><span class="o">:</span> <span class="s2">&quot;AUT&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;gold&quot;</span><span class="o">:</span> <span class="mi">9</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;silver&quot;</span><span class="o">:</span> <span class="mi">5</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;bronze&quot;</span><span class="o">:</span> <span class="mi">7</span>
</span><span class='line'>    <span class="p">},</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="s2">&quot;code&quot;</span><span class="o">:</span> <span class="s2">&quot;USA&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;gold&quot;</span><span class="o">:</span> <span class="mi">9</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;silver&quot;</span><span class="o">:</span> <span class="mi">7</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;bronze&quot;</span><span class="o">:</span> <span class="mi">10</span>
</span><span class='line'>    <span class="p">},</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="s2">&quot;code&quot;</span><span class="o">:</span> <span class="s2">&quot;EGY&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;gold&quot;</span><span class="o">:</span> <span class="mi">2</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;silver&quot;</span><span class="o">:</span> <span class="mi">3</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;bronze&quot;</span><span class="o">:</span> <span class="mi">12</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>A basic implementation is easy enough:</p>

<figure class='code'><figcaption><span>R.sortBy defaults to ascending order</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='javascript'><span class='line'><span class="nx">R</span><span class="p">.</span><span class="nx">sortBy</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;silver&#39;</span><span class="p">),</span> <span class="nx">array</span><span class="p">);</span>  <span class="c1">// [{&quot;code&quot;: &quot;EGY&quot;, &quot;silver&quot;: 3}, {&quot;code&quot;: &quot;AUT&quot;, &quot;silver&quot;: 5}, {&quot;code&quot;: &quot;USA&quot;, &quot;silver&quot;: 7}]</span>
</span></code></pre></td></tr></table></div></figure>


<p><code>R.sortBy</code> sorts according to a given function, in this case <code>R.prop</code> (where <code>'silver'</code> could be substituted for any other property).</p>

<p>To ensure the order (ascending vs. descending), we can introduce <code>R.comparator</code>:</p>

<figure class='code'><figcaption><span>R.comparator enforces descending order, but &#8220;AUT&#8221; and &#8220;USA&#8221; tie</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='javascript'><span class='line'><span class="kr">const</span> <span class="nx">goldComparator</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">comparator</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">gt</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;gold&#39;</span><span class="p">,</span> <span class="nx">a</span><span class="p">),</span> <span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;gold&#39;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)));</span>
</span><span class='line'><span class="nx">R</span><span class="p">.</span><span class="nx">sort</span><span class="p">(</span><span class="nx">goldComparator</span><span class="p">,</span> <span class="nx">array</span><span class="p">);</span>    <span class="c1">//  [{&quot;code&quot;: &quot;AUT&quot;, &quot;gold&quot;: 9}, {&quot;code&quot;: &quot;USA&quot;, &quot;gold&quot;: 9}, {&quot;code&quot;: &quot;EGY&quot;, &quot;silver&quot;: 3}]</span>
</span></code></pre></td></tr></table></div></figure>


<p>How can we handle tiebreakers? That is, as in the example abolve, what if two elements in the array have identical <code>gold</code> values and we attempt to sort by <code>gold</code> &mdash; which should be sorted first? We can ensure a deterministic result with predictable tiebreaks using comparators and <code>R.either</code>.</p>

<figure class='code'><figcaption><span>R.comparator enforces descending order and second R.comparator passed to R.either breaks ties</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='javascript'><span class='line'><span class="kr">const</span> <span class="nx">goldComparator</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">comparator</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">gt</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;gold&#39;</span><span class="p">,</span> <span class="nx">a</span><span class="p">),</span> <span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;gold&#39;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)));</span>
</span><span class='line'><span class="kr">const</span> <span class="nx">silverComparator</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">comparator</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">gt</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;silver&#39;</span><span class="p">,</span> <span class="nx">a</span><span class="p">),</span> <span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;silver&#39;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)));</span>
</span><span class='line'>
</span><span class='line'><span class="nx">R</span><span class="p">.</span><span class="nx">sort</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">either</span><span class="p">(</span><span class="nx">goldComparator</span><span class="p">,</span> <span class="nx">silverComparator</span><span class="p">),</span> <span class="nx">array</span><span class="p">);</span>    <span class="c1">// [{&quot;code&quot;: &quot;USA&quot;, &quot;gold&quot;: 9, &quot;silver&quot;: 7}, {&quot;code&quot;: &quot;AUT&quot;, &quot;gold&quot;: 9, &quot;silver&quot;: 5}, {&quot;code&quot;: &quot;EGY&quot;, &quot;gold&quot;: 2, &quot;silver&quot;: 3}]</span>
</span></code></pre></td></tr></table></div></figure>


<p>Finally, what if we need more than one tiebreaker? How do we handle objects that have identical <code>gold</code> AND <code>silver</code> values? <code>R.either</code> expects two arguments, so the solution is to create a variadic implementation of <code>R.either</code>, one that will accept an unknown number of arguments, so we can pass tiebreaker comparators for all possible situations:</p>

<figure class='code'><figcaption><span>Addresses all edge cases: sort by gold; if gold ties sort by silver; if silver ties sort by bronze; if bronze ties sort by country code</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='javascript'><span class='line'><span class="kr">const</span> <span class="nx">variadicEither</span> <span class="o">=</span> <span class="p">(</span><span class="nx">head</span><span class="p">,</span> <span class="p">...</span><span class="nx">tail</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">reduce</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">either</span><span class="p">,</span> <span class="nx">head</span><span class="p">,</span> <span class="nx">tail</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="kr">const</span> <span class="nx">goldComparator</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">comparator</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">gt</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;gold&#39;</span><span class="p">,</span> <span class="nx">a</span><span class="p">),</span> <span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;gold&#39;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)));</span>
</span><span class='line'><span class="kr">const</span> <span class="nx">silverComparator</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">comparator</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">gt</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;silver&#39;</span><span class="p">,</span> <span class="nx">a</span><span class="p">),</span> <span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;silver&#39;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)));</span>
</span><span class='line'><span class="kr">const</span> <span class="nx">bronzeComparator</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">comparator</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">gt</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;bronze&#39;</span><span class="p">,</span> <span class="nx">a</span><span class="p">),</span> <span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;bronze&#39;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)));</span>
</span><span class='line'><span class="kr">const</span> <span class="nx">codeComparator</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">comparator</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">R</span><span class="p">.</span><span class="nx">lt</span><span class="p">(</span><span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;code&#39;</span><span class="p">,</span> <span class="nx">a</span><span class="p">),</span> <span class="nx">R</span><span class="p">.</span><span class="nx">prop</span><span class="p">(</span><span class="s1">&#39;code&#39;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)));</span>    <span class="c1">// sorts alphabetically by country code</span>
</span><span class='line'>
</span><span class='line'><span class="nx">R</span><span class="p">.</span><span class="nx">sort</span><span class="p">(</span><span class="nx">variadicEither</span><span class="p">([</span><span class="nx">goldComparator</span><span class="p">,</span> <span class="nx">silverComparator</span><span class="p">,</span> <span class="nx">bronzeComparator</span><span class="p">,</span> <span class="nx">codeComparator</span><span class="p">]),</span> <span class="nx">array</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>The crux of this solution is <code>variadicEither</code>, a <a href="https://en.wikipedia.org/wiki/Variadic_function">variadic</a> re-implementation of <code>R.either</code> that can accept a variable number of arguments. It uses <code>head</code> (first argument) and <code>...tail</code> (all remaining arguments) to reduce over all arguments and return a function that addresses all tiebreak possibilities. R.sort expects a comparator function, which <code>R.either</code> and <code>variadicEither</code> both return.</p>

<p>Of course this solution still has a bit of boilerplate (repetition of <code>R.comparator(...)</code>). For a reusable <code>sortByProps</code> implementation that takes an array of props and a list, see <a href="https://github.com/ramda/ramda/wiki/Cookbook#sort-a-list-by-array-of-props-if-first-prop-equivalent-sort-by-second-etc">this Ramda.js recipe</a> that I recently added.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Knexfile Configuration for Heroku Deployment]]></title>
    <link href="http://cek.io/blog/2016/10/24/knex-configuration-heroku/"/>
    <updated>2016-10-24T14:29:50+01:00</updated>
    <id>http://cek.io/blog/2016/10/24/knex-configuration-heroku</id>
    <content type="html"><![CDATA[<p>I recently deployed a simple Express server to Heroku. The project used <a href="http://knexjs.org/">Knex.js</a> for SQL queries and database migrations.</p>

<p>While deploying, I ran into some issues with my knexfile. That is, I was able to create the database using the Heroku CLI, but running the migrations and configuring the database connection took a bit of finessing.</p>

<p>Long story short, two parts:</p>

<h3>1. Database URL (Connection)</h3>


<p>Find your database url. Using Heroku CLI, running <code>heroku config</code> (or <code>heroku config --app [app name]</code>) will return something like the following:</p>

<figure class='code'><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=''><span class='line'>cek app $ heroku config
</span><span class='line'>=== app Config Vars
</span><span class='line'>DATABASE_URL: postgres://asdghjlkjh:sadv09787-vnbmvliHJV@ec7-23-123-986-12.compute-1.amazonaws.com:5432/asfhlkjh1234</span></code></pre></td></tr></table></div></figure>


<p>Copy and paste the DATABASE_URL as your Knexfile&rsquo;s <code>connection</code> value.</p>

<h3>2. SSL</h3>


<p>Heroku requires SSL for PostgreSQL connections. There are two options (and potentially a third in the future):</p>

<ul>
<li><strong>(Confirmed)</strong> Add an <code>ssl: true</code> key/value pair to the Knexfile</li>
<li><strong>(Confirmed)</strong> Set an environment variable using Heroku CLI: <code>heroku config:set PGSSLMODE=require</code></li>
<li><strong>(Unsupported, but may be implemented in future versions of Knex)</strong> Add a <code>'?ssl=true'</code> query parameter to your database URL (knexfile&rsquo;s <code>connection</code>).</li>
</ul>


<p>With those two things in mind, a Knexfile like the following will work just fine:</p>

<figure class='code'><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>
</pre></td><td class='code'><pre><code class=''><span class='line'>module.exports = {
</span><span class='line'>    client: 'pg',
</span><span class='line'>    debug: true,
</span><span class='line'>    connection: DB_URL,
</span><span class='line'>    migrations: {
</span><span class='line'>        tableName: 'migrations'
</span><span class='line'>    },
</span><span class='line'>    ssl: true
</span><span class='line'>}</span></code></pre></td></tr></table></div></figure>




<h3>Further resources:</h3>


<ul>
<li><a href="https://github.com/tgriesser/knex/issues/239#issuecomment-42278076">Related Github issue on Knex project</a></li>
<li><a href="https://github.com/HalahRaadSalih/deploy-to-heroku-with-db">Heroku/Knex walkthrough</a></li>
<li><a href="http://jakehp.github.io/2015/07/10/Knex-Postgres-Heroku/">Similar issue</a></li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[D3 and React Faux DOM]]></title>
    <link href="http://cek.io/blog/2016/07/07/d3-and-react-faux-dom/"/>
    <updated>2016-07-07T00:56:50+01:00</updated>
    <id>http://cek.io/blog/2016/07/07/d3-and-react-faux-dom</id>
    <content type="html"><![CDATA[<p><strong>Author&rsquo;s Note:</strong> This post makes <a href="http://cek.io/blog/2015/06/23/react-d3/">my original post exploring React + D3</a> obselete. I strongly recommend <code>react-faux-dom</code> (<a href="https://github.com/Olical/react-faux-dom">on Github</a>) over my previous post&rsquo;s suggestion.</p>

<hr>


<p><strong>TL;DR</strong>, Hear it straight from the lib author: Oliver Caldwell wrote <a href="http://oli.me.uk/2015/09/09/d3-within-react-the-right-way/">this blog post</a> about <code>react-faux-dom</code>, which enables a cleanly organized and powerful combination of React and D3.</p>

<p>That post in four bullet points:</p>

<ul>
<li>D3 works by <strong>mutating</strong> the DOM. Select a DOM element, append children, etc.</li>
<li>React works by <strong>reconciling</strong> the DOM. Build a tree, compare to DOM, determine which elements to add/remove/change.</li>
<li>DOM mutation (like D3 does) and DOM reconciliation (like React does) don&rsquo;t work together so well.</li>
<li><code>react-faux-dom</code> makes a fake DOM to support D3. It might seem silly, but it enables us to support D3 while remaining within React.</li>
</ul>


<p>(<strong>Note</strong>: regarding the second bullet, <a href="https://facebook.github.io/react/docs/reconciliation.html">this post from the React docs</a> is worth a reread.)</p>

<p>Using a fake DOM means we can drop D3 scripts into a React component&rsquo;s <code>render()</code> function and it&rsquo;ll just work. It was trivial to prove out in a production PR:</p>

<figure class='code'><figcaption><span> (sparkline.js)</span> <a href='http://cek.io/downloads/code/react-faux-dom/sparkline.js'>download</a></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>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="c1">// inspired by: https://github.com/QubitProducts/d3-react-sparkline/blob/master/src/d3-react-sparkline.js</span>
</span><span class='line'><span class="kr">import</span> <span class="nx">d3</span> <span class="nx">from</span> <span class="s1">&#39;d3&#39;</span>
</span><span class='line'><span class="kr">import</span> <span class="nx">React</span> <span class="nx">from</span> <span class="s1">&#39;react&#39;</span>
</span><span class='line'><span class="kr">import</span> <span class="nx">ReactFauxDOM</span> <span class="nx">from</span> <span class="s1">&#39;react-faux-dom&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="kr">export</span> <span class="kr">const</span> <span class="nx">Sparkline</span> <span class="o">=</span> <span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
</span><span class='line'>  <span class="nx">propTypes</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">width</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">number</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">height</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">number</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">data</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">array</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">interpolation</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">oneOfType</span><span class="p">([</span>
</span><span class='line'>      <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">string</span><span class="p">,</span>
</span><span class='line'>      <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="kd">function</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="nx">render</span> <span class="p">()</span> <span class="p">{</span>
</span><span class='line'>    <span class="kr">const</span> <span class="p">{</span><span class="nx">width</span><span class="p">,</span> <span class="nx">height</span><span class="p">,</span> <span class="nx">data</span><span class="p">,</span> <span class="nx">interpolation</span><span class="p">,</span> <span class="nx">max</span><span class="p">}</span> <span class="o">=</span> <span class="k">this</span><span class="p">.</span><span class="nx">props</span>
</span><span class='line'>
</span><span class='line'>    <span class="kr">const</span> <span class="nx">el</span> <span class="o">=</span> <span class="nx">d3</span><span class="p">.</span><span class="nx">select</span><span class="p">(</span><span class="nx">ReactFauxDOM</span><span class="p">.</span><span class="nx">createElement</span><span class="p">(</span><span class="s1">&#39;g&#39;</span><span class="p">))</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">props</span><span class="p">)</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;data&#39;</span><span class="p">,</span> <span class="kc">null</span><span class="p">)</span>
</span><span class='line'>
</span><span class='line'>    <span class="kr">const</span> <span class="nx">x</span> <span class="o">=</span> <span class="nx">d3</span><span class="p">.</span><span class="nx">scale</span><span class="p">.</span><span class="nx">linear</span><span class="p">()</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">range</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="nx">width</span><span class="p">])</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">domain</span><span class="p">(</span><span class="nx">d3</span><span class="p">.</span><span class="nx">extent</span><span class="p">(</span><span class="nx">data</span><span class="p">,</span> <span class="p">(</span><span class="nx">d</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">i</span><span class="p">))</span>
</span><span class='line'>
</span><span class='line'>    <span class="kr">const</span> <span class="nx">y</span> <span class="o">=</span> <span class="nx">d3</span><span class="p">.</span><span class="nx">scale</span><span class="p">.</span><span class="nx">linear</span><span class="p">()</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">range</span><span class="p">([</span><span class="nx">height</span><span class="p">,</span> <span class="mi">0</span><span class="p">])</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">domain</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="nx">max</span><span class="p">])</span>
</span><span class='line'>
</span><span class='line'>    <span class="kr">const</span> <span class="nx">line</span> <span class="o">=</span> <span class="nx">d3</span><span class="p">.</span><span class="nx">svg</span><span class="p">.</span><span class="nx">line</span><span class="p">()</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">x</span><span class="p">((</span><span class="nx">d</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">x</span><span class="p">(</span><span class="nx">i</span><span class="p">))</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">y</span><span class="p">((</span><span class="nx">d</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nx">y</span><span class="p">(</span><span class="nx">d</span><span class="p">))</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">interpolate</span><span class="p">(</span><span class="nx">interpolation</span><span class="p">)</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">el</span><span class="p">.</span><span class="nx">append</span><span class="p">(</span><span class="s1">&#39;path&#39;</span><span class="p">)</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">datum</span><span class="p">(</span><span class="nx">data</span><span class="p">)</span>
</span><span class='line'>      <span class="p">.</span><span class="nx">attr</span><span class="p">({</span>
</span><span class='line'>        <span class="nx">key</span><span class="o">:</span> <span class="s1">&#39;sparkline&#39;</span><span class="p">,</span>
</span><span class='line'>        <span class="nx">className</span><span class="o">:</span> <span class="s1">&#39;sparkline&#39;</span><span class="p">,</span>
</span><span class='line'>        <span class="nx">d</span><span class="o">:</span> <span class="nx">line</span>
</span><span class='line'>      <span class="p">})</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="nx">el</span><span class="p">.</span><span class="nx">node</span><span class="p">().</span><span class="nx">toReact</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>Rendering a sparkline is as simple as <code>&lt;Sparkline width={500} height={500} max={10} data={[1, 3, 2, 5, 4]} interpolation={"basis"} /&gt;</code>. We get the benefits of React semantics AND the D3 API, both neatly organized in their respective places.</p>

<p>I consider it a clear win to maintain React component organization while leveraging the power of all that D3 offers, but I suppose what it comes down to is this:</p>

<blockquote class="twitter-tweet" data-conversation="none" data-lang="en"><p lang="en" dir="ltr">For me, it&#39;s about worrying about the right &quot;lines&quot; to draw in your app, then fill the few shapes those lines create with garbage and ship.</p>&mdash; Ryan Florence (@ryanflorence) <a href="https://twitter.com/ryanflorence/status/702538809569726464">February 24, 2016</a></blockquote>


<script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>


<p>So many code design decisions boil down to the border between things. The interface. The &ldquo;line&rdquo; between where React component code belongs and where D3 code belongs. Ultimately, this still leaves us to fill in the lines with whatever we choose to write, but this library&rsquo;s placement of the &ldquo;line&rdquo; is an improvement over anything else I&rsquo;ve seen.</p>

<p>As the author writes, &ldquo;All [React and D3] concepts remain the same, react-faux-dom is just the glue in the middle.&rdquo; This clean separation is hugely helpful in writing dataviz React components with D3.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[A Single Set of Color Vars With PostCSS]]></title>
    <link href="http://cek.io/blog/2016/06/30/postcss-color-vars/"/>
    <updated>2016-06-30T13:05:35+01:00</updated>
    <id>http://cek.io/blog/2016/06/30/postcss-color-vars</id>
    <content type="html"><![CDATA[<p>In this post, I describe how to create a single list of color variables (in JavaScript) so that those colors can be shared across JavaScript files and CSS stylesheets. Using PostCSS within a Webpack app, I outline the problem of sharing styles between CSS and JS and how it can be solved. For step-by-step code examples, skip ahead to &ldquo;Enter PostCSS (Problem Solved)&rdquo;.</p>

<h3>The Problem We&#8217;re Solving</h3>


<p>At my day job, we&rsquo;d had a <code>colors.css</code> file for a while, where we define all the hex codes for our color scheme, as defined by our designers. It looked something like this:</p>

<figure class='code'><figcaption><span> (colors.css)</span> <a href='http://cek.io/downloads/code/postcss/colors.css'>download</a></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='css'><span class='line'><span class="nd">:root</span> <span class="p">{</span>
</span><span class='line'>  <span class="o">--</span><span class="nb">black</span><span class="o">:</span> <span class="m">#1d3744</span><span class="p">;</span>
</span><span class='line'>  <span class="o">--</span><span class="nb">white</span><span class="o">:</span> <span class="m">#fff</span><span class="p">;</span>
</span><span class='line'>  <span class="o">--</span><span class="nb">red</span><span class="o">:</span> <span class="m">#c21e48</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>This enabled us to use the same colors in any of our other CSS files using CSS modules:</p>

<figure class='code'><figcaption><span> (component-specific.css)</span> <a href='http://cek.io/downloads/code/postcss/component-specific.css'>download</a></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='css'><span class='line'><span class="k">@import</span> <span class="s2">&quot;../theme/colors&quot;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="nc">.my-special-component</span> <span class="p">{</span>
</span><span class='line'>  <span class="k">background-color</span><span class="o">:</span> <span class="n">var</span><span class="p">(</span><span class="o">--</span><span class="nb">white</span><span class="p">);</span>
</span><span class='line'>  <span class="k">color</span><span class="o">:</span> <span class="n">var</span><span class="p">(</span><span class="o">--</span><span class="nb">red</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Straightforward, keeps things DRY, makes it easy to change colors when it strikes the designer&rsquo;s fancy, etc.</p>

<p>For a long time, while our CSS colors were nicely organized, our JS colors weren&rsquo;t. We have colors in our D3 visualizations and our inline styles on React components. As a simple improvement, I decided to pull all our colors into a single map that could be read by both our CSS and JS files. <em>NB</em>: this post is about CSS <em>colors</em>, but can apply to any CSS variables you&rsquo;d like shared to JS.</p>

<!--more-->




<h3>Enter PostCSS (Problem Solved)</h3>


<p><a href="https://github.com/postcss/postcss">PostCSS</a> does a lot of things. I&rsquo;ll leave it as an exercise to the reader to explore the <a href="https://github.com/postcss/postcss/blob/master/docs/plugins.md">various plugins</a> (or just <a href="https://github.com/postcss/postcss#plugins">some of the most popular ones</a>).</p>

<p>For my purposes, I needed <a href="https://github.com/postcss/postcss-loader">postcss-loader</a> (a loader for Webpack), <a href="https://github.com/MoOx/postcss-cssnext">postcss-cssnext</a> (enables the latest CSS syntax, which we were already using through <a href="http://cssnext.io/">cssnext</a>), <a href="https://github.com/postcss/postcss-url">postcss-url</a>, and <a href="https://github.com/postcss/postcss-import">postcss-import</a>.</p>

<p>The change was effectively X steps (X easy steps to a single list of color variables!):</p>

<ol>
  <li>
    Add PostCSS plugins to package.json:

    <figure class='code'><figcaption><span> (package.json)</span> <a href='http://cek.io/downloads/code/postcss/package.json'>download</a></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='json'><span class='line'><span class="p">{</span>
</span><span class='line'>  <span class="err">//</span> <span class="err">...</span>
</span><span class='line'>
</span><span class='line'>  <span class="nt">&quot;devDependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>    <span class="err">//</span> <span class="err">...</span>
</span><span class='line'>    <span class="nt">&quot;postcss-browser-reporter&quot;</span><span class="p">:</span> <span class="s2">&quot;^0.5.0&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;postcss-cssnext&quot;</span><span class="p">:</span> <span class="s2">&quot;^2.6.0&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;postcss-import&quot;</span><span class="p">:</span> <span class="s2">&quot;^8.1.2&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;postcss-loader&quot;</span><span class="p">:</span> <span class="s2">&quot;^0.9.1&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;postcss-reporter&quot;</span><span class="p">:</span> <span class="s2">&quot;^1.3.3&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;postcss-url&quot;</span><span class="p">:</span> <span class="s2">&quot;^5.1.2&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="err">//</span> <span class="err">...</span>
</span><span class='line'>  <span class="p">},</span>
</span><span class='line'>
</span><span class='line'>  <span class="err">//</span> <span class="err">...</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>
  </li>

  <li>
    Since I had previously been using cssnext, I followed [these migration steps](http://cssnext.io/postcss/#postcss-loader) to upgrade to postcss-cssnext. This meant swapping the `cssnext-loader` for `postcss-loader` in my Webpack loaders, removing cssnext from my webpack config, and adding the postcss options to webpack config:

    <figure class='code'><figcaption><span> (webpack.config.js)</span> <a href='http://cek.io/downloads/code/postcss/webpack.config.js'>download</a></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>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="p">{</span>
</span><span class='line'>  <span class="nx">module</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">loaders</span><span class="o">:</span> <span class="p">[</span>
</span><span class='line'>      <span class="p">{</span>
</span><span class='line'>          <span class="nx">test</span><span class="o">:</span>   <span class="sr">/\.css$/</span><span class="p">,</span>
</span><span class='line'>          <span class="nx">loader</span><span class="o">:</span> <span class="s2">&quot;style-loader!css-loader!postcss-loader&quot;</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 class="nx">postcss</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">webpack</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="p">[</span>
</span><span class='line'>      <span class="nx">require</span><span class="p">(</span><span class="s2">&quot;postcss-import&quot;</span><span class="p">)({</span> <span class="nx">addDependencyTo</span><span class="o">:</span> <span class="nx">webpack</span> <span class="p">}),</span>
</span><span class='line'>      <span class="nx">require</span><span class="p">(</span><span class="s2">&quot;postcss-url&quot;</span><span class="p">)(),</span>
</span><span class='line'>      <span class="nx">require</span><span class="p">(</span><span class="s2">&quot;postcss-cssnext&quot;</span><span class="p">)({</span>
</span><span class='line'>        <span class="nx">features</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>          <span class="nx">customProperties</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>            <span class="nx">variables</span><span class="o">:</span> <span class="nx">colorVars</span> <span class="c1">// `colorVars` will be defined above, see step 4.</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 class="nx">require</span><span class="p">(</span><span class="s2">&quot;postcss-browser-reporter&quot;</span><span class="p">)(),</span>
</span><span class='line'>      <span class="nx">require</span><span class="p">(</span><span class="s2">&quot;postcss-reporter&quot;</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>
  </li>

  <li>
    Add a colors.js. I chose to CONSTANT_CASE the variables (for idiomatic JS).

    <figure class='code'><figcaption><span> (colors.js)</span> <a href='http://cek.io/downloads/code/postcss/colors.js'>download</a></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='js'><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="p">{</span>
</span><span class='line'>  <span class="s2">&quot;BLACK&quot;</span><span class="o">:</span> <span class="s2">&quot;#1d3744&quot;</span><span class="p">,</span>
</span><span class='line'>  <span class="s2">&quot;WHITE&quot;</span><span class="o">:</span> <span class="s2">&quot;#fff&quot;</span><span class="p">,</span>
</span><span class='line'>  <span class="s2">&quot;RED&quot;</span><span class="o">:</span> <span class="s2">&quot;#c21e48&quot;</span><span class="p">,</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>
  </li>

  <li>
    Require `colors.js` in webpack.config.js.

    <figure class='code'><figcaption><span> (require-colors.js)</span> <a href='http://cek.io/downloads/code/postcss/require-colors.js'>download</a></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='js'><span class='line'><span class="c1">// to be added aboce `module.exports` of webpack.config.js</span>
</span><span class='line'><span class="kd">var</span> <span class="nx">colorVars</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s2">&quot;./app/constants/colors&quot;</span><span class="p">)</span>
</span></code></pre></td></tr></table></div></figure>
  </li>

  <li>
    (OPTIONAL) Because I wanted CSS variables to be lowercase and hyphen-separated so I could maintain our old `color: var(&#8211;light-grey);` syntax, I added a transformation from the constant case (using Ramda&#8217;s `curry` and `reduce`):

    <figure class='code'><figcaption><span> (case-transform.js)</span> <a href='http://cek.io/downloads/code/postcss/case-transform.js'>download</a></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='js'><span class='line'><span class="c1">// to be added above `module.exports` of webpack.config.js</span>
</span><span class='line'><span class="c1">// color vars in JS are CONST_CASE, but need to be converted to hyphen-case for CSS</span>
</span><span class='line'><span class="kr">const</span> <span class="nx">renameKeys</span> <span class="o">=</span> <span class="nx">R</span><span class="p">.</span><span class="nx">curry</span><span class="p">((</span><span class="nx">renameFn</span><span class="p">,</span> <span class="nx">obj</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">{</span>
</span><span class='line'>  <span class="k">return</span> <span class="nx">R</span><span class="p">.</span><span class="nx">reduce</span><span class="p">((</span><span class="nx">acc</span><span class="p">,</span> <span class="nx">key</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">acc</span><span class="p">[</span><span class="nx">renameFn</span><span class="p">(</span><span class="nx">key</span><span class="p">)]</span> <span class="o">=</span> <span class="nx">obj</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">acc</span>
</span><span class='line'>  <span class="p">},</span> <span class="p">{},</span> <span class="nx">R</span><span class="p">.</span><span class="nx">keys</span><span class="p">(</span><span class="nx">obj</span><span class="p">))</span>
</span><span class='line'><span class="p">})</span>
</span><span class='line'><span class="kr">const</span> <span class="nx">constCaseToHyphenCase</span> <span class="o">=</span> <span class="p">(</span><span class="nx">str</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">{</span> <span class="k">return</span> <span class="nx">str</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/_/g</span><span class="p">,</span> <span class="s2">&quot;-&quot;</span><span class="p">).</span><span class="nx">toLowerCase</span><span class="p">()</span> <span class="p">}</span>
</span><span class='line'><span class="kd">var</span> <span class="nx">colorVars</span> <span class="o">=</span> <span class="nx">renameKeys</span><span class="p">(</span><span class="nx">constCaseToHyphenCase</span><span class="p">,</span> <span class="nx">require</span><span class="p">(</span><span class="s2">&quot;./app/constants/colors&quot;</span><span class="p">))</span>
</span></code></pre></td></tr></table></div></figure>
  </li>
  
  <li>
    Go forth and use styles!
    
    <figure class='code'><figcaption><span> (color-vars.js)</span> <a href='http://cek.io/downloads/code/postcss/color-vars.js'>download</a></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='js'><span class='line'><span class="c1">// we can now do this in React components or any other JS file</span>
</span><span class='line'><span class="kd">var</span> <span class="nx">colors</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s2">&quot;app/constants/colors&quot;</span><span class="p">)</span>
</span><span class='line'><span class="c1">// ...</span>
</span><span class='line'><span class="nx">render</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>  <span class="k">return</span> <span class="o">&lt;</span><span class="nx">div</span> <span class="nx">style</span><span class="o">=</span><span class="p">{{</span><span class="nx">backgroundColor</span><span class="o">:</span> <span class="nx">colors</span><span class="p">.</span><span class="nx">white</span><span class="p">}}</span> <span class="o">/&gt;</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>

    <figure class='code'><figcaption><span> (color-vars.css)</span> <a href='http://cek.io/downloads/code/postcss/color-vars.css'>download</a></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='css'><span class='line'><span class="c">/* and this still works, without even needing to `@import &quot;../theme/colors&quot;;` */</span>
</span><span class='line'><span class="nc">.my-special-component</span> <span class="p">{</span>
</span><span class='line'>  <span class="k">background-color</span><span class="o">:</span> <span class="n">var</span><span class="p">(</span><span class="o">--</span><span class="nb">white</span><span class="p">);</span>
</span><span class='line'>  <span class="k">color</span><span class="o">:</span> <span class="n">var</span><span class="p">(</span><span class="o">--</span><span class="nb">red</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>
  </li>

</ol>


<p>And that&rsquo;s it! Now, in addition to everything it already did, running <code>webpack-dev-server</code> will (1) compile using PostCSS, (2) read from colors.js, and (3) set all colors in colors.js as global CSS variables.</p>

<h3>Limitations</h3>


<p>The one limitation is hot-reloading. That is, hot reloading works perfectly on changes to JavaScript files and CSS files, with one exception: colors.js. Since colors.js is read on build, we need to restart the webpack dev server anytime we change or add a color variable. <a href="https://stackoverflow.com/questions/35174069/can-i-have-a-single-variables-file-using-cssnext-with-webpack">This question</a> poses effectively the same issue (&ldquo;&hellip;every time I change a variable I have to restart the webpack dev server&rdquo;). For now, that&rsquo;s a tradeoff I can live with.</p>

<h3>Parting thoughts</h3>


<p>This new pattern enables much more inline styling with JavaScript. That is, now our React components and D3 visualizations can, in theory, read style variables from JavaScript and never know about CSS.</p>

<p>Following this to its extreme of no-CSS/all-JS may seem crazy, but I remain curious. <a href="https://www.youtube.com/watch?v=ERB1TJBn32c">A lot</a> <a href="https://twitter.com/necolas/status/718517376711405568">has been</a> <a href="https://speakerdeck.com/vjeux/react-css-in-js">said</a> about how inline styles with JavaScript may be the future. At a minimum, it&rsquo;s convenient and fun to do more JS and less CSS. I&rsquo;m excited to see how the community experiments with inline styling and if there come to be best practices around separation of concerns.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[React Conf Reactions]]></title>
    <link href="http://cek.io/blog/2016/02/27/react-conf/"/>
    <updated>2016-02-27T21:43:32+00:00</updated>
    <id>http://cek.io/blog/2016/02/27/react-conf</id>
    <content type="html"><![CDATA[<p>The React.js Conf was a blast. All the talks were recorded and can be watched <a href="https://www.youtube.com/playlist?list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">here</a>. My full bullet point notes are <a href="http://cek.io/downloads/react_conf_notes.txt">here</a>, but what follows are some more readable reactions to the conference.</p>

<p>First of all, a special thanks to the organizers and speakers. This was a very well run conference with some high-class talks. From breakfast Monday through to the closing reception on Tuesday, with the single exception of <a href="https://twitter.com/kentcdodds/status/702201425133064192">jackhammer noises during some of the talks</a> (what are you gonna do about construction next door?), everything was very well done.</p>

<p>Moving on, I learned a ton, got to know some awesome members of this community, and met some incredible people who&rsquo;ve influenced my career (by giving talks, authoring open-source, or otherwise helping me write better code). Here&rsquo;s a couple of my main takeaways, in no particular order.</p>

<!--more-->


<ol>
<li><p>I came into the conference with React.js and Redux experience, but little to no knowledge of GraphQL, Relay, or React Native. I was not disappointed then, that the majority (maybe two-thirds?) of the talks addressed exactly those things. For a long time, React Native has been on my list of new tech to explore, as someone who&rsquo;s never written anything for mobile. GraphQL and Relay, meanwhile, could be directly applicable to my everyday work. And I&rsquo;m of course always pleased to learn new things about what I already &ldquo;know&rdquo;, like aspects of React performance that I haven&rsquo;t thought about.</p></li>
<li><p>If the majority of the talks addressed React.js, React Native, GraphQL, and Relay, the remainder focused on areas of tech that I rarely if ever consider. Talks covered subjects like <a href="https://www.youtube.com/watch?v=ty2bFeOdGeI&amp;index=7&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">virtual reality</a>, <a href="https://www.youtube.com/watch?v=GnIrNYtmRDg&amp;index=8&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">hardware</a>, and <a href="https://www.youtube.com/watch?v=Xnqy_zkBAew&amp;index=18&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">graphics</a>. I may never focus the majority of my time on any of these, but it&rsquo;s eye-opening and motivating to see people pushing the limits of what can be done.</p></li>
<li><p>A few of my favorite talks:</p>

<ul>
<li>Andy Matuschak, who worked on the gesture system for iOS, <a href="https://www.youtube.com/watch?v=uBYPqb83C7k&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY&amp;index=9">presented some of the problems (and potential solutions) facing mobile gestures</a>. I don&rsquo;t even do mobile, but his talk was engaging, entertaining, and informative.</li>
<li><a href="https://www.youtube.com/watch?v=feUYwoLhE_4&amp;index=3&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">Isaac Salier-Hellendag announced Draft.js</a>, a new open-source framework for building rich text editors. I&rsquo;ve worked on exactly this problem, implementing a textarea that allows for Facebook-style (using <code>@</code>) mentions, so I totally resonated with his walkthrough of the problem and implementation, and I&rsquo;m excited to give Draft.js a try.</li>
<li>Jared Forsyth addressed exactly the situation I&rsquo;m in, providing <a href="https://www.youtube.com/watch?v=-jwQ3sGoiXg&amp;index=34&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">an overview of React, Redux, and Relay</a> (with discussions of ClojureScript and Om/next mixed in) and how to determine which to use and when.</li>
<li>Nicolas Gallagher, who&rsquo;s SUIT CSS project I&rsquo;ve used, pushed things a step farther and proposed taking styles a step farther (moving CSS entirely into JS) in his <a href="https://www.youtube.com/watch?v=RBg2_uQE4KM&amp;index=22&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">talk on React Native for Web</a>.</li>
<li>Jamison Dance stepped away from React long enough to discuss <a href="https://www.youtube.com/watch?v=txxKx_I39a8&amp;index=30&amp;list=PLb0IAmt7-GS0M8Q95RIc2lOM6nc77q1IY">Elm and what JavaScript can learn from it</a> (read: immutability, types, pure functions). Fantastic talk with great examples and fun slides.</li>
</ul>
</li>
<li><p>Any post-conference list would be incomplete without mentioning the things I&rsquo;m excited to explore and implement:</p>

<ul>
<li>As I already mentioned, I want to give Draft.js a long look and consider using it in production.</li>
<li>I was already interested in GraphQL and Relay, and want to take a few days to see if it could make sense at work.</li>
<li>I&rsquo;m all for moving away from CSS in favor of JavaScript solutions, so I want to learn from React Native for Web and consider the OSS solutions for JS styles.</li>
<li>My app at work, like so many others, is slow on app initialization, so I want to consider how to improve that based on ideas presented at the conference.</li>
<li>I want to finally give React Native a try in a side project.</li>
<li>Finally, I&rsquo;m already sold on ideas from functional programming like immutability and reducing side effects, but I want to check out Flow for gradual type checking and I want to learn Elm rather than only doing FP in JavaScript.</li>
</ul>
</li>
</ol>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[The Hammer of JavaScript (and Other Tools for Other Nails)]]></title>
    <link href="http://cek.io/blog/2016/02/08/javascript-hammer/"/>
    <updated>2016-02-08T16:10:04+00:00</updated>
    <id>http://cek.io/blog/2016/02/08/javascript-hammer</id>
    <content type="html"><![CDATA[<p><em>The one where I get a harsh reminder to question my instincts from a real-life experience of <a href="https://xkcd.com/1319/">this XKCD comic</a>.</em></p>

<p>As a mental exercise, a friend proposed the following potential interview question: given a directory with 10,000 files of text, how would you extract all the phone numbers from that directory into a single file?</p>

<p>My immediate thought: this would be a basic assessment of someone&rsquo;s knowledge of:</p>

<ol>
<li>regular expressions to match patterns of numbers</li>
<li>how to programmatically read/write files</li>
<li>basic algorithmic complexity for iterating through files quickly.</li>
</ol>


<p>I even knew how I&rsquo;d implement it: use node&rsquo;s filesystem module to read the files, parse them for regex matches, and write all matches to a new file.</p>

<p><img class="right" src="http://cek.io/images/hammer-nail.jpg" width="300"></p>

<p>I was intrigued enough that I decided to prove it out. I wrote a basic phone number regex by hand (<code>\d{3}(-|\s|\.)?\d{3}(-|\s|\.)?\d{4}\</code> (for 3 digits, 3 digits, and 4 digits separated by hyphens, periods, spaces, or nothing), and looked into popular phone number regexes. I realized how unfamiliar I am with <a href="https://nodejs.org/api/fs.html">Node&rsquo;s filesystem module</a> (<code>readdir</code> and <code>readFile</code> and <code>writeFile</code>). Then I got curious about <a href="https://docs.npmjs.com/getting-started/publishing-npm-packages">publishing npm packages</a>. Before I knew it, I&rsquo;d spent a couple hours and produced a <a href="https://www.npmjs.com/package/collect-phone-numbers">somewhat polished npm project</a> for this hypothetical task.</p>

<p>And it was all wrong.</p>

<!--more-->


<p>The thought process I used was logical. My work as a software engineer focuses almost entirely on the web, JavaScript, build tools, UI features, HTTP servers. I&rsquo;m comfortable with databases, front- and back-end code, version control, and countless other things. But that&rsquo;s a small subset of software! Classic hammer/nail.</p>

<p>To Wikipedia:</p>

<blockquote><p>Software: any set of instructions that directs a computer to perform specific tasks or operations.</p><footer><strong>Wikipedia</strong> <cite><a href='https://en.wikipedia.org/wiki/Software'>&#8220;Software&#8221;</a></cite></footer></blockquote>


<p>Software is about problem-solving. But problems can&rsquo;t be solved well without being understood. And they won&rsquo;t be well understood if we assume we should use the same solution every time. There&rsquo;s something to be said for using the tools you know, but software also requires a humility to recognize when a given tool is the wrong one.</p>

<p>In this case, I skipped the step of analyzing the problem. I didn&rsquo;t think about the specifics of the problem, the tradeoffs of time, or the alternative solutions I could choose. This was a one-time, approximate task. It was unlikely to be repeated often enough to make automating worthwhile. And yet I instinctually went with what I knew, implementing a &ldquo;good&rdquo;, &ldquo;complete&rdquo; solution that was really just a picture of overengineering.</p>

<p><img class="left" src="https://imgs.xkcd.com/comics/automation.png" width="300"></p>

<p>For a problem like this, why use another language or abstraction when it can be done via the command line, the text interface for the computer itself and a much more direct interface with the filesystem? Why use a language like JavaScript that&rsquo;s best suited for the web or pull in Node just for the sake of using a tool I know?</p>

<p>These are questions I won&rsquo;t soon forget to ask myself when I take on a new problem. Hopefully that&rsquo;ll prevent me from falling into traps that webcomics are made of. I know for sure that, next time I&rsquo;m presented with a problem of finding text within a filesystem, I&rsquo;ll remember that tools like <code>grep</code> were made for exactly that. A simpler, less time-instensive, and more appropriate solution.</p>

<p><code>egrep "\b[[:digit:]]{3}(-|\s|.)?[[:digit:]]{3}(-|\s|.)?[[:digit:]]{4}\b" ./* &gt; ./nums.txt</code></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[JavaScript's Call Stack, Callback Queue, and Event Loop]]></title>
    <link href="http://cek.io/blog/2015/12/03/event-loop/"/>
    <updated>2015-12-03T14:01:39+00:00</updated>
    <id>http://cek.io/blog/2015/12/03/event-loop</id>
    <content type="html"><![CDATA[<p>In this video, Philip Roberts clears up a lot of the details surrounding JavaScript&rsquo;s call stack, callback queue, and event loop. Feel free to skip this blog post and spend a half hour watching <a href="https://www.youtube.com/watch?v=8aGhZQkoFbQ">the video</a> instead. But if you&rsquo;d rather skim my highlights, don&rsquo;t let me stop you!</p>

<iframe width="560" height="315" src="https://www.youtube.com/embed/8aGhZQkoFbQ" frameborder="0" allowfullscreen></iframe>




<!--more-->




<h3>What is JavaScript</h3>


<p>What is JavaScript anyway? Some words:</p>

<ul>
<li>It&rsquo;s a single-threaded, non-blocking, asynchronous, concurrent language&#8221;</li>
<li>It has a call stack, an event loop, a callback queue, some other apis and stuff</li>
</ul>


<p>If you&rsquo;re like me (or Philip Roberts, it seems), these words themselves don&rsquo;t mean a ton. So let&rsquo;s parse that out.</p>

<h3>JavaScript Runtimes</h3>


<p>JavaScript runtimes (like V8) have a heap (memory allocation) and stack (execution contexts). But they don&rsquo;t have <code>setTimeout</code>, the DOM, etc. Those are web APIs in the browser.</p>

<h3>JavaScript as we know it</h3>


<p>JavaScript in the browser has:</p>

<ul>
<li>a runtime like V8 (heap/stack)</li>
<li>Web APIs that the browser provides, like the DOM, ajax, and <code>setTimeout</code></li>
<li>a callback queue for events with callbacks like <code>onClick</code>, <code>onLoad</code>, <code>onDone</code></li>
<li>an event loop</li>
</ul>


<p><img src="http://cek.io/images/event-loop/javascript.png"></p>

<h3>What&#8217;s the call stack?</h3>


<p>JavaScript is single-threaded, meaning it has a single call stack, meaning it can do one thing at a time. The call stack is basically a data structure which records where in the program we are. If we step into a function, we push something onto the stack. If we return from a function, we pop off the top of the stack.</p>

<p>When our program throws an error, we see the call stack in the console. We see the state of the stack (which functions have been called) when that error happened.</p>

<h3>Blocking</h3>


<p>An important question that this relates to: what happens when things are slow? In other words, blocking. Blocking doesn&rsquo;t have a strict definition; really it&rsquo;s just things that are slow. <code>console.log</code> isn&rsquo;t slow, but <code>while</code> loops from 1 to 1,000,000,000, image processing, or network requests are slow. Those things that are slow and on the stack are blocking.</p>

<p>Since JS is single-threaded, we make a network request and have to wait until it&rsquo;s done. This is a problem in the browser&mdash;while we wait on a request, the browser is blocked (can&rsquo;t click things, submit forms, etc.). The solution is asynchronous callbacks.</p>

<h3>Concurrency, where we realize there&#8217;s a lie above</h3>


<p>It&rsquo;s a lie that JavaScript can only do one thing at a time. It&rsquo;s true: JavaScript the runtime can only do one thing at a time. It can&rsquo;t make an ajax request while doing other code. It can&rsquo;t do a <code>setTimeout</code> while doing other code. But we can do things concurrently, because the browser is more than the runtime (remember the grainy image above).</p>

<p>The stack can put things into web APIs, which (when done) push callbacks onto task queue, and then&hellip;the event loop. Finally we get to the event loop. It&rsquo;s the simplest little piece in this equation, and it has one very simple job. Look at the stack and look at the task queue; if the stack is empty, it takes the first thing off of the queue and pushes it onto the stack (back in JS land, back inside V8).</p>

<h3>Louping it all together</h3>


<p>Philip built an awesome tool to visualize all of this, called <a href="http://latentflip.com/loupe">Loupe</a>. It&rsquo;s a tool that can visualize the JavaScript runtime at runtime.</p>

<p>Let&rsquo;s use it to look at a simple example: logging a few things to the console, with one <code>console.log</code> happening asynchronously in a <code>setTimeout</code>.</p>

<p><img src="http://cek.io/images/event-loop/loupe.gif"></p>

<p>What&rsquo;s actually happening here? Let&rsquo;s go through it:</p>

<ol>
<li>We step into the <code>console.log('Hi');</code> function, so it&rsquo;s pushed onto the call stack.</li>
<li><code>console.log('Hi');</code> returns, so it&rsquo;s popped off the top of the stack.</li>
<li>We step into the <code>setTimeout</code> function, so it&rsquo;s pushed onto the call stack.</li>
<li><code>setTimeout</code> is part of the web API, so the web API handles that and times out the 2 seconds.</li>
<li>We continue our script, stepping into the <code>console.log('Everybody')</code> function, pushing it onto the stack.</li>
<li><code>console.log('Everybody')</code> returns, so it&rsquo;s popped off the stack.</li>
<li>The 2-second timeout completes, so the callback moves to the callback queue.</li>
<li>The event loop checks if the call stack is empty. If it were <em>not</em> empty, it would wait. Because it <em>is</em> empty, the callback is pushed onto the call stack.</li>
<li><code>console.log('Everybody')</code> returns, so it&rsquo;s popped off the call stack.</li>
</ol>


<p>An interesting aside: <code>setTimeout(function(...), 0)</code>. <code>setTimeout</code> with 0 isn&rsquo;t necessarily intuitive, except when considered in the context of call stack and event loop. It basically defers something until the stack is clear.</p>

<h3>Considering UI render performance</h3>


<p>To this back to something more surface level, something we deal with every day, let&rsquo;s consider rendering. The browser is constrained by what we&rsquo;re doing in JavaScript. It would like to repaint the screen every 16.6ms (or 60 frames/second). But it can&rsquo;t actually do a render if there&rsquo;s code on the stack.</p>

<p>As Philip says,</p>

<blockquote><p>When people say &#8220;don&#8217;t block the event loop&#8221;, this is exactly what they&#8217;re talking about. Don&#8217;t put slow code on the stack because, when you do that, the browser can&#8217;t do what it needs to do, like create a nice fluid UI.</p><footer><strong>Philip Roberts</strong> <cite><a href='https://www.youtube.com/watch?v=8aGhZQkoFbQ'>&#8220;What the Heck Is the Event Loop Anyway&#8221;</a></cite></footer></blockquote>


<p>So, for example, scroll handlers trigger a lot and can cause a lagging UI. Incidentally, this is the clearest explanation I&rsquo;ve heard of debouncing, which is exactly what you need to do to prevent blocking the event loop (that is, let&rsquo;s only do those slow events every X times the scroll handler triggers).</p>

<h3>Closing</h3>


<p>In summary, that&rsquo;s what the heck the event loop is. Philip&rsquo;s talk helped me understand a lot of what JavaScript is, what it isn&rsquo;t, which parts of it are runtime vs. browser, and how to use it effectively. Give the talk a watch!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Pruning Code]]></title>
    <link href="http://cek.io/blog/2015/11/21/code-pruning/"/>
    <updated>2015-11-21T17:23:14+00:00</updated>
    <id>http://cek.io/blog/2015/11/21/code-pruning</id>
    <content type="html"><![CDATA[<p>It was Friday afternoon, the end of the day, at the end of a long week of urgent bugfixes to prepare a release. Our next features hadn&rsquo;t been fully designed and approved, all the high-priority bugs had been identified and fixed, and I was left with a few hours to choose what to work on.</p>

<p>These moments are some of my favorites, opportunities to focus on the important/non-urgent tasks like performance improvements, refactors, new technologies, and code cleanup. So I spent the last few hours of the day on that last item: pruning old code from the codebase.</p>

<p>We all know that pruning is about <a href="http://dictionary.reference.com/browse/pruning">removing the superfluous</a>, which is by definition a good thing (&ldquo;superfluous&rdquo; being &ldquo;unnecessary&rdquo;, after all), but the benefits of pruning also include:</p>

<ul>
<li>improving or maintaining health</li>
<li>reducing risk</li>
<li>increasing yield or quality</li>
</ul>


<p><em>Source</em>: <a href="https://en.wikipedia.org/wiki/Pruning">&ldquo;Pruning&rdquo;, Wikipedia</a></p>

<p>Ok, ok, we&rsquo;re not talking about plant health, risk of falling branches, or yield of flowers and fruits. But it&rsquo;s a pretty straightforward metaphor for code.</p>

<!--more-->


<p>The pull request I ended up submitting did three things (removed, removed, removed, like pruning):</p>

<ul>
<li>It removed the <code>/** @jsx React.DOM */</code> pragma, which has been unnecessary since React 0.12 (we&rsquo;re currently running 0.13).</li>
<li>It removed <code>Immutable</code> as a global variable (we&rsquo;re using Immutable JS on most&mdash;but not all&mdash;pages, and we want to explicitly require libraries for each file/component, plus&hellip;<a href="http://c2.com/cgi/wiki?GlobalVariablesAreBad">yeah</a>).</li>
<li>It removed a couple helper functions from a utility file the depends on lodash.js, which largely overlaps with our Ramda.js library.</li>
</ul>


<p>These are simple things. Remove unnecessary lines of code. Clarify what a given file is doing by making modules more explicit. Reduce the number of dependencies and the weight of the codebase.</p>

<p>These are clearly beneficial things. Deleting the unnecessary reduces mental overhead. Explicit requires ease our ability to reason about a piece of code. Removing an external library improves performance.</p>

<p>Simple, beneficial, and yet when do these things get accomplished? As I referenced above, rarely. It was only after feature development, testing, and bugfixing that I even considered it. To some degree that&rsquo;s on me: it&rsquo;s a technical discipline like performance or code quality that needs to be considered at each step along the way. But it&rsquo;s also on the development process and management: if it&rsquo;s not prioritized and time isn&rsquo;t allotted, it won&rsquo;t happen! That simple.</p>

<p>Anyway, that&rsquo;s my argument for code pruning. Regardless of whether anyone else finds it valid, it&rsquo;s a personal goal of mine to spend a couple hours a week on exactly that. Removing dependencies, deleting dead code, refactoring. And who knows, perhaps with a little more disciplined code pruning along the way, code quality will improve and our team will have fewer weeks of urgent bugfixes.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[An Imperative Declaration]]></title>
    <link href="http://cek.io/blog/2015/10/23/imperative-declaration/"/>
    <updated>2015-10-23T21:42:28+01:00</updated>
    <id>http://cek.io/blog/2015/10/23/imperative-declaration</id>
    <content type="html"><![CDATA[<p>A few hours ago, my understanding of imperative and declarative programming was effectively: imperative is about &ldquo;how&rdquo; something should happen and declarative is about &ldquo;what&rdquo; should happen. Not exactly authoritative, so I spent these last couple hours trying to clear that up by finding conclusive answers to the following questions:</p>

<ul>
<li>What&rsquo;s the difference between imperative programming and declarative programming?</li>
<li>Is functional programming a subset of declarative programming?</li>
<li>If so, what&rsquo;s an example of declarative programming that&rsquo;s not functional?</li>
</ul>


<p>Unfortunately, no definitive answers. Or perhaps too many &ldquo;definitive&rdquo; answers. So here&rsquo;s where I stand.</p>

<!--more-->


<h3>The Backstory</h3>

<p>Let me back up for a second. I went through a similar exercise a little while back. Google even pointed me to <a href="http://latentflip.com/imperative-vs-declarative/">this handy article</a>, which I found so useful that I summarized it in a <a href="http://stackoverflow.com/a/28216263">StackOverflow answer</a>.</p>

<p>I was pleasantly surprised by the three upvotes that came over the next few months, but of course all pleasant things must come to an end:</p>

<blockquote><p>As with frighteningly many answers to this question, your example of &#8216;declarative&#8217; programming is an example of functional programming. The semantics of &#8216;map&#8217; are &#8216;apply this function to the elements of the array in order&#8217;. You&#8217;re not allowing the runtime any leeway in the order of execution.</p></blockquote>


<p>Silly me, thinking I&rsquo;d grasped a complex but fundamental concept, and sillier me, thinking I should share it. On the internet.</p>

<p>Thus began my quest to answer those three questions. (1) What <em>is</em> the difference between imperative and declarative? (2) Can I safely call functional programming a subset of declarative programming? (3) If so, what&rsquo;s an example of declarative programming that isn&rsquo;t functional?</p>

<h3>Defining the Question(s)</h3>

<p>I first tried to make sense of the critique I&rsquo;d received on StackOverflow: &ldquo;&hellip;your example of &lsquo;declarative&rsquo; programming is an example of functional programming.&rdquo; I suppose that&rsquo;s what rendered my answer inappropriate for the question &ldquo;What is the difference between declarative and imperative programming?&rdquo;. Easy solution&mdash;just look back to the <a href="http://stackoverflow.com/a/1784702">accepted answer</a>&hellip;and find that the same commenter left <a href="https://stackoverflow.com/questions/1784664/what-is-the-difference-between-declarative-and-imperative-programming#comment52439156_1784702">a very similar critique</a>.</p>

<p>This seemed to imply that functional programming and declarative programming are <em>not</em> synonymous (which I already believed), but also that there&rsquo;s a significant difference between declarative programming and functional programming (which I hadn&rsquo;t recognized). So what is it? Going back even farther, if this is a valid critique, what&rsquo;s the difference between imperative and declarative to begin with? I decided to reassess my answer.</p>

<h3>Definitions</h3>

<p><strong>Imperative Programming:</strong></p>

<ul>
<li>&ldquo;Telling the &lsquo;machine&rsquo; how to do something, and as a result what you want to happen will happen.&rdquo; <a href="http://latentflip.com/imperative-vs-declarative/">(Latentflip)</a></li>
<li>&ldquo;A programming paradigm that uses statements that change a program&rsquo;s state. In much the same way that the imperative mood in natural languages expresses commands, an imperative program consists of commands for the computer to perform. Imperative programming focuses on describing how a program operates.&rdquo; <a href="https://en.wikipedia.org/wiki/Imperative_programming">(Wikipedia)</a></li>
<li>&ldquo;Any programming language that specifies explicit manipulation of the state of the computer system.&rdquo; <a href="http://foldoc.org/imperative%20programming">(Foldoc)</a></li>
</ul>


<p><strong>Declarative Programming:</strong></p>

<ul>
<li>&ldquo;Telling the &lsquo;machine&rsquo; what you would like to happen, and let the computer figure out how to do it.&rdquo; <a href="http://latentflip.com/imperative-vs-declarative/">(Latentflip)</a></li>
<li>&ldquo;A programming paradigm&hellip;that expresses the logic of a computation without describing its control flow. Many languages applying this style attempt to minimize or eliminate side effects by describing what the program should accomplish in terms of the problem domain, rather than describing how to go about accomplishing it as a sequence of the programming language primitives (the how being left up to the language&rsquo;s implementation).&rdquo; <a href="https://en.wikipedia.org/wiki/Declarative_programming">(Wikipedia)</a></li>
<li>&ldquo;Any relational language or functional language. These kinds of programming language describe relationships between variables in terms of functions or inference rules, and the language executor (interpreter or compiler) applies some fixed algorithm to these relations to produce a result.&rdquo; <a href="http://foldoc.org/declarative%20languages">(Foldoc)</a></li>
</ul>


<p><strong>Takeaways:</strong></p>

<ul>
<li>How (imperative) vs. what (declarative)</li>
<li>Using control flow and mutating state (imperative) vs. minimizing/eliminating control flow and side effects</li>
</ul>


<p>Here&rsquo;s where we already see some divergence in definition. <em>Minimizing</em> vs <em>eliminating</em> opens us up to an ambiguity. Does declarative programming necessitate absolutely no side effects, or just a preference for immutability? Is imperative programming about the lowest level of specified instructions, or just less abstraction?</p>

<h3>Arriving Back Full Circle</h3>

<p>With these thoughts in mind, I&rsquo;d argue that declarative and imperative are <em>relative</em> terms, not absolute black and white, but a spectrum of lighter and darker gray. Generalizing, declarative programming is about specifying the &ldquo;what&rdquo;, by way of certain abstractions (for example, functional operations like <code>map</code>) or by removing abstractions (for example, plain HTML rather than jQuery DOM manipulation), whereas declarative programming is about the &ldquo;how&rdquo;, using lower level steps (for example, <code>for</code> loops).</p>

<p>So I stand by my original sentiments, and my original answer on StackOverflow. If we think of imperative and declarative as a spectrum rather than a binary either-or, we can use it as an effective part of our vocabulary rather than a confusing semantic argument.</p>

<p>That&rsquo;s where I&rsquo;m at anyway. I hope you don&rsquo;t find it &ldquo;frighteningly&rdquo; off-target.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Performance Process: Takeaways From AEA]]></title>
    <link href="http://cek.io/blog/2015/10/09/performance/"/>
    <updated>2015-10-09T18:39:03+01:00</updated>
    <id>http://cek.io/blog/2015/10/09/performance</id>
    <content type="html"><![CDATA[<p>The stars have aligned lately to focus my attention on performance. Consider the following:</p>

<ul>
<li>A few months ago, I was tasked with assessing and documenting the differences between our app&rsquo;s functionality/performance in Chrome vs. Firefox.</li>
<li>This exercise resulted in a pull request that improved Firefox performance by over 2 seconds (~25%) on initial page load.</li>
<li><a href="http://cek.io/blog/2015/10/08/an-event-apart/">Earlier this week</a>, two separate talks (by <a href="http://twitter.com/yeseniaa">Yesenia Perez-Cruz</a> and <a href="http://twitter.com/lara_hogan">Lara Hogan</a>) focused on designing for performance.</li>
<li>Also this week, <a href="http://www.nateberkopec.com/2015/10/07/frontend-performance-chrome-timeline.html">Nate Berkopec&rsquo;s post on front end performance</a> made the rounds on Hacker News.</li>
</ul>


<p>What does this add up to? I&rsquo;ve been thinking a lot about performance, particularly front end performance of web apps. In this post, I&rsquo;ll summarize some takeaways from AEA regarding performance, particularly as they relate to integrating performance into planning and design.</p>

<!--more-->




<h3>Set up for failure</h3>


<p>Summarizing a few points from Yesenia&rsquo;s talk, consider this project plan, one that we&rsquo;ve all presumed to follow:</p>

<p><img src="http://cek.io/images/performance/ideal-plan.png"></p>

<p>But then realize that, due to biz dev requirements, delays in research, and longer-than-expected design time, all while keeping the same sprint/client/deployment deadline, the actual project plan looks like this:</p>

<p><img src="http://cek.io/images/performance/actual-plan.png"></p>

<p>We&rsquo;ve all seen it! And it probably happens more often this way than the ideal case. What&rsquo;s the definition of insanity again?</p>

<p>Now I could speculate and hypothesize about the underlying issues of failed project management, but I&rsquo;ll leave that to someone else. I want to focus on performance. A question: with that development timeline in mind, when do we think about performance? During the software development segment, right?</p>

<p><img src="http://cek.io/images/performance/perf-timeline-reality.png"></p>

<p>But why? We developers think we can implement user functionality, meet the design specs, and still have time left over to optimize at the end. But that never happens. Could we not consider performance at the beginning of the process?</p>

<p><img src="http://cek.io/images/performance/perf-timeline-improved.png"></p>

<p>We need to think about performance as a design feature. We need to think about performance early. We need to prioritize page speed and load times just as much as UX and beautiful interfaces. But how?</p>

<h3>Performance Budgets</h3>


<p><span class='caption-wrapper'><img class='caption' src='http://cek.io/images/performance/dilbert-budget.gif' width='' height='' title='"We only have the budget for a poor job"'><span class='caption-text'>&ldquo;We only have the budget for a poor job&rdquo;</span></span></p>

<p>I&rsquo;m not sure we&rsquo;re being cheap <em>or</em> smart by thinking about performance this way. We don&rsquo;t have any budget at all! A theme throughout AEA, and not just in Yesenia&rsquo;s and Lara&rsquo;s talks, was <strong>setting a performance budget</strong>.</p>

<p>Yesenia explained that a performance budget is both &ldquo;a performance goal used to guide design &amp; development&rdquo; and &ldquo;a tangible way to talk about performance.&rdquo; How well do those conversations about performance-intensive features usually go? For developers, it&rsquo;s often either &ldquo;no, we can&rsquo;t do that&rdquo; or a resigned &ldquo;ok, I guess we have to do it.&rdquo;</p>

<p><span class='caption-wrapper'><img class='caption' src='http://cek.io/images/performance/google-designer-developer.png' width='' height='' title='One incredible trick will render 728,000 Google results obselete!'><span class='caption-text'>One incredible trick will render 728,000 Google results obselete!</span></span></p>

<p>What if, instead of a win-lose scenario between designers and devs, the conversation was framed around a budget? We talk about the inherent tradeoffs between technologies, so why not consider performance tradeoffs in discussions about design?</p>

<p>&ldquo;But how do I go about setting a performance budget?&rdquo;, you might ask. Yesenia and Lara made some suggestions:</p>

<ul>
<li><em>Browser-based approach</em>: &ldquo;our pages should weigh no more than 400kb, and make no more than 15 requests.&rdquo;</li>
<li><em>User experience-based</em>: &ldquo;our pages should take no more than 10 seconds to load over a sub-3G connection.&rdquo;</li>
<li><em>Look to your competitors</em>: aim for a 20% improvement over your competitors.</li>
</ul>


<p>I&rsquo;m still working on this, on how to practically establish a performance budget on the job. I don&rsquo;t have access to my competitors&#8217; product, so for now I can only set the goal as arbitrarily better performance.</p>

<p>One thing I will say: everything I&rsquo;ve said in this blogpost has to be a culture change. Stealing from Lara&rsquo;s talk, it can&rsquo;t be all on one individual. You have to establish a culture of performance.</p>

<blockquote class="twitter-tweet" lang="en"><p lang="en" dir="ltr">&quot;There should be no performance cops or janitors. It&#39;s not sustainable. You need a culture of performance.&quot; <a href="https://twitter.com/lara_hogan">@lara_hogan</a> <a href="https://twitter.com/hashtag/aeaaus?src=hash">#aeaaus</a></p>&mdash; Chris EK (@cek_io) <a href="https://twitter.com/cek_io/status/651406414225649666">October 6, 2015</a></blockquote>


<script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[An Event Apart]]></title>
    <link href="http://cek.io/blog/2015/10/08/an-event-apart/"/>
    <updated>2015-10-08T22:09:32+01:00</updated>
    <id>http://cek.io/blog/2015/10/08/an-event-apart</id>
    <content type="html"><![CDATA[<p>This week, I had the good fortune of attending <a href="http://aneventapart.com/event/austin-2015">An Event Apart in Austin, TX</a>. Coordinated by the same great people behind <a href="http://alistapart.com/">A List Apart</a>, An Event Apart (AEA) is two days of fantastic talks about the web&mdash;content, design, development&mdash;and a full-day workshop (A Day Apart). Many of the concepts we now take for granted as web best practices, like mobile first and responsive design, have been introduced and elaborated at AEA events.</p>

<p>Before I continue, some thanks are in order. AEA made three scholarships available to Flatiron School alumni. Now, in retrospect, I realize the value of attending is well worth the $1,000+ price tag, but the reality is: I wouldn&rsquo;t have been able to justify that cost on my own. So some major thank yous for making this happen, first to AEA for offering those scholarships, and then to Flatiron School for enabling that hookup. <strong>Thank you!</strong></p>

<p>Moving on, I want to share some of my notes and highlights from the three days. For a quick summary of the conference in the form of 140-character highlights, <a href="https://twitter.com/hashtag/aeaaus">#aeaaus</a> is a great place to start. A summary of my takeaways from the conference (as well as my full notes) are below.</p>

<!--more-->


<p>My full unfiltered/unedited notes can be viewed <a href="http://cek.io/downloads/aea_notes.txt">here</a>, and videos of all talks will be posted online at some point, so you should sign up <a href="http://aneventapart.com/subscribe">here</a>. For now, these are my highlights/summaries of each talk, some of which may turn into full posts.</p>

<ul>
<li><strong>Jeffrey Zeldman</strong> opened the conference by telling his personal narrative, from starving artist to professional creative to disillusioned advertiser to web practitioner. <br><em>Takeaways</em>: Talk about the problems you&rsquo;re solving, not the aesthetics; attitude trumps work; blog!</li>
<li><strong>Yesenia Perez-Cruz</strong> discussed design from the perspective of performance. <br><em>Takeaways</em>: performance isn&rsquo;t a last-minute add-on, it&rsquo;s part of the UX; consider performance at the beginning.</li>
<li><strong>Jen Simmons</strong> presented modern layouts and recent/upcoming additions to CSS. <br><em>Takeaways</em>: we see the same layout with sidebar everywhere; use CSS shapes/flexbox; layout should serve content.</li>
<li><strong>Cameron Moll</strong> walked us through interfaces and the ways we interact with them. <br><em>Takeaways</em>: the best interface is the one within reach; forget about mobile/desktop and instead build a unified interface.</li>
<li><strong>Karen McGrane</strong> summarized issues around content and how it should be separated from form. <br><em>Takeaways</em>: separating form from content makes web design much easier than an interconnected blob of a website.</li>
<li><strong>Ethan Marcotte</strong> argued that laziness is good, that less is more when it comes to responsive design. <br><em>Takeaways</em>: use flexible layout systems rather than device-specific designs.</li>
<li><strong>Lara Callender Hogan</strong> built on Yesenia&rsquo;s talk about performance <br><em>Takeaways</em>: we optimize for design/layout but not page speed; need happy medium of aesthetics and speed; tips for image optimization; need a culture of performance; set a performance budget.</li>
<li><strong>Eric Meyer</strong> presented an incredibly vulnerable talk about personal tragedy and how his experience as someone in crisis informs his understanding of web design<br><em>Takeaways</em>: design with crisis-driven personas in mind; empathy; don&rsquo;t consider just the ideal user.</li>
<li><strong>Jason Grigsby</strong> got into the nitty gritty of responsive images.<br><em>Takeaways</em>: responsive images matter for resolution switching and art direction; look-ahead preparser.</li>
<li><strong>Brad Frost</strong> framed web design from the perspective of atoms &ndash;> molecules &ndash;> organisms.<br><em>Takeaways</em>: design systems of components not pages.</li>
<li><strong>Matt Haughey</strong> brought a customer service perspective to web design.<br><em>Takeaways</em>: everyone at Slack does customer service; need to have empathy for the user.</li>
<li><strong>Jeremy Keith</strong> took us through the history of the web and argued for using basic, supported technologies that don&rsquo;t break.<br><em>Takeaways</em>: identify core functionality and implement using simplest technology, then enhance.</li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Ramda's Once]]></title>
    <link href="http://cek.io/blog/2015/07/14/once/"/>
    <updated>2015-07-14T16:29:18+01:00</updated>
    <id>http://cek.io/blog/2015/07/14/once</id>
    <content type="html"><![CDATA[<p>Someone recently described to me that, in an interview, he was asked to implement a function that would only run once, even if invoked multiple times. This immediately made me think of <a href="http://ramdajs.com/">Ramda</a>&mdash;my go-to JavaScript library (think <a href="http://underscorejs.org/">Underscore</a> or <a href="https://lodash.com/">lodash</a>, but with a little more functional programming flavor)&mdash;and its <a href="http://ramdajs.com/docs/#once"><code>once</code> function</a>:</p>

<p><img src="http://cek.io/images/ramda-once.png"></p>

<!--more-->


<p>Great, <code>once</code> &ldquo;accepts a function fn and returns a function that guards invocation of fn such that fn can only ever be called once, no matter how many times the returned function is invoked.&rdquo; Getting back to the original question (i.e., in an interview), this would be one kind of answer. It would show knowledge of the JavaScript ecosystem, some of its libraries (and <a href="http://fr.umio.us/why-ramda/">why to use them</a>), and how to apply it to a specific problem.</p>

<p>That said, let&rsquo;s go deeper&mdash;how would we implement <code>once</code> from scratch? Since Ramda&rsquo;s implementation worked so well for us, let&rsquo;s look no further than Ramda. <a href="https://github.com/ramda/ramda/blob/master/src/once.js">Looking at the source</a>, it&rsquo;s relatively straightforward to see what&rsquo;s going on:</p>

<figure class='code'><figcaption><span> (once.js)</span> <a href='http://cek.io/downloads/code/ramda/once.js'>download</a></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>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="kd">var</span> <span class="nx">_curry1</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./internal/_curry1&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="nx">_curry1</span><span class="p">(</span><span class="kd">function</span> <span class="nx">once</span><span class="p">(</span><span class="nx">fn</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">called</span> <span class="o">=</span> <span class="kc">false</span><span class="p">,</span> <span class="nx">result</span><span class="p">;</span>
</span><span class='line'>    <span class="k">return</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="nx">called</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="nx">result</span><span class="p">;</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>        <span class="nx">called</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>
</span><span class='line'>        <span class="nx">result</span> <span class="o">=</span> <span class="nx">fn</span><span class="p">.</span><span class="nx">apply</span><span class="p">(</span><span class="k">this</span><span class="p">,</span> <span class="nx">arguments</span><span class="p">);</span>
</span><span class='line'>        <span class="k">return</span> <span class="nx">result</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>Let&rsquo;s ignore <code>_curry1</code> for now (though we&rsquo;ll get to it), and rewrite as follows:</p>

<p><img src="http://cek.io/images/ramda-once-2.png"></p>

<p>And there we have it! So what&rsquo;s actually happening here? The first several lines are simple: we declare the variables <code>called</code> (initialized to <code>false</code>) and <code>result</code>, return <code>result</code> if <code>called</code> is true, otherwise set <code>called</code> to true and then assign <code>result = fn.apply(this, arguments);</code>.</p>

<p>What is that line doing? It&rsquo;s using <code>apply()</code>, which <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply">&ldquo;calls a function with a given this value and arguments provided as an array&rdquo;</a>. It&rsquo;s a way of dealing with scope, making sure we pass the right value of <code>this</code> to <code>fn</code>. In our example above (<code>console.log...</code>), this isn&rsquo;t an issue, so we could plausibly replace the line in question with <code>result = fn(arguments);</code>.</p>

<p>It is an issue, however, when scope and <code>this</code> matter. For example, using Ramda&rsquo;s example of wrapping an <code>addOne</code> function (<code>var addOneOnce = R.once(function(x){ return x + 1; });</code>) using <code>once</code>, we can see that not using <code>apply()</code> (left) breaks the adding behavior, but it works when using <code>apply()</code> (right).</p>

<p><img src="http://cek.io/images/ramda-apply-no-apply.png"></p>

<p>This occurs (on the left) because without passing the correct value for <code>this</code>, <code>x</code> in the <code>addOne</code> function becomes <code>"[object Arguments]"</code>, which, when 1 is added, becomes <code>"[object Arguments]1"</code>. On the other hand (on the right), given the correct value for <code>this</code>, <code>x</code> becomes 10 (or whatever argument we pass) and the result is correct.</p>

<p>And that about concludes this post, with one open question remaining: currying? Ramda&rsquo;s implementation of <code>once</code> uses <code>curry1</code>, in keeping with its API (functions first, data last) and functional style. Currying is just a way of turning a function that expects n parameters into one that, when supplied less than n parameters, returns a new function awaiting the remaining parameters. It&rsquo;s a handy way that Ramda enables us to build functions, pass those functions around as first-class objects, and call when ready. Back to our <code>once</code> examples, currying is what&rsquo;s happening when we call <code>once(addOne)</code> and see <code>function anonymous()</code>. <code>once(addOne)</code> expects one more parameter, so we call <code>once(addOne)(10)</code> and get 11.</p>

<h3>Resources</h3>


<p><a href="http://fr.umio.us/why-ramda/">Why Ramda?</a><br>
<a href="http://fr.umio.us/favoring-curry/">Favoring Curry</a><br></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Rethinking UI Patterns: D3 and React]]></title>
    <link href="http://cek.io/blog/2015/06/23/react-d3/"/>
    <updated>2015-06-23T13:17:36+01:00</updated>
    <id>http://cek.io/blog/2015/06/23/react-d3</id>
    <content type="html"><![CDATA[<p><strong>Author&rsquo;s note:</strong> I&rsquo;ve followed up on this post with <a href="http://cek.io/blog/2016/07/06/d3-and-react-faux-dom/">another one</a>. I&rsquo;m no longer a fan of building up SVG elements in React components the way I propose in this post. You should read the other post to see what I recommend.</p>

<hr>


<p>Imagine the entirety of your organization&rsquo;s chatroom communications. Imagine making sense of those communications in a single interactive visualization, one that factors in date and time, chatroom name, individual participants&#8217; names, and message content.</p>

<p>I recently implemented just such a feature. While something like this of course requires back end analytics, aggregations of data, and &ldquo;data science&rdquo; that can handle such &ldquo;big data,&rdquo; it also relates to user interface (UI), the subject of this blog post.</p>

<!--more-->




<h3>UI background</h3>


<p>Until recently, this app&rsquo;s client-side UI was built entirely in <a href="http://emberjs.com/">Ember.js</a>, a framework intended for &ldquo;ambitious&rdquo; applications (and thus a good fit!). Over time, however, the UI team came to realize some of Ember&rsquo;s limitations, some of those conventions and patterns inherent to the framework that&mdash;rather than making developers&#8217; lives easier, as is any framework&rsquo;s aim&mdash;posed challenges to the organization and maintenance of our codebase.</p>

<p>Enter <a href="https://facebook.github.io/react/">React.js</a>, a UI library that solely addresses issues in the view layer. Over the last 5-6 months, we have been porting Ember code over to React, started using React for all greenfield components, and made React the standard for our UI. This blog post won&rsquo;t cover the litany of (fiercely debated) pros and cons of Ember vs. React, but suffice it to say that React has made us on the product development team unanimously happier.</p>

<h3>D3</h3>


<p>All of that is just background to the feature I initially described, because a data visualization isn&rsquo;t implemented solely in Ember or React. Or is it?</p>

<h4>The old way</h4>


<p>The short answer is no. To effectively create data visualizations, we have leveraged <a href="http://d3js.org/">D3.js</a>, a JavaScript library for manipulating documents. D3 functions similarly to jQuery in that it emphasizes selectors and listeners; for example, to initialize a D3 svg, we might write <code>d3.select('body').append('svg') #...</code> and, from there, append rectangles and lines, bind click and hover actions, etc. Not so different from a basic jQuery application (<code>$('button').on('click', function()...)</code>).</p>

<p>That said, what D3 ultimately produces is a series of DOM elements, specifically SVG elements. Some basic D3 code might look like:</p>

<figure class='code'><figcaption><span>d3-viz.js </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='javascript'><span class='line'><span class="nx">d3</span><span class="p">.</span><span class="nx">select</span><span class="p">(</span><span class="s1">&#39;body&#39;</span><span class="p">).</span><span class="nx">append</span><span class="p">(</span><span class="s1">&#39;svg&#39;</span><span class="p">)</span>
</span><span class='line'>        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;width&#39;</span><span class="p">,</span> <span class="mi">500</span><span class="p">)</span>
</span><span class='line'>        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;height&#39;</span><span class="p">,</span> <span class="mi">500</span><span class="p">)</span>
</span><span class='line'>        <span class="p">.</span><span class="nx">selectAll</span><span class="p">(</span><span class="s1">&#39;rect&#39;</span><span class="p">)</span>
</span><span class='line'>                <span class="p">.</span><span class="nx">data</span><span class="p">([</span><span class="mi">10</span><span class="p">,</span><span class="mi">20</span><span class="p">,</span><span class="mi">30</span><span class="p">])</span>
</span><span class='line'>                <span class="p">.</span><span class="nx">enter</span><span class="p">()</span>
</span><span class='line'>                <span class="p">.</span><span class="nx">append</span><span class="p">(</span><span class="s1">&#39;rect&#39;</span><span class="p">)</span>
</span><span class='line'>                        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;width&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">){</span> <span class="k">return</span> <span class="nx">d</span> <span class="o">*</span> <span class="mi">10</span> <span class="p">})</span>
</span><span class='line'>                        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;height&#39;</span><span class="p">,</span> <span class="mi">20</span><span class="p">)</span>
</span><span class='line'>                        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;fill&#39;</span><span class="p">,</span> <span class="s1">&#39;blue&#39;</span><span class="p">)</span>
</span><span class='line'>                        <span class="p">.</span><span class="nx">attr</span><span class="p">(</span><span class="s1">&#39;y&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">d</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="p">{</span> <span class="k">return</span> <span class="nx">i</span> <span class="o">*</span> <span class="mi">50</span> <span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p>That code then maps to SVG elements in the DOM, looking something like this:</p>

<figure class='code'><figcaption><span>d3-svg.html </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='html'><span class='line'><span class="nt">&lt;svg</span> <span class="na">width=</span><span class="s">&quot;500&quot;</span> <span class="na">height=</span><span class="s">&quot;500&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>                <span class="nt">&lt;rect</span> <span class="na">width=</span><span class="s">&quot;100&quot;</span> <span class="na">height=</span><span class="s">&quot;20&quot;</span> <span class="na">fill=</span><span class="s">&quot;blue&quot;</span> <span class="na">y=</span><span class="s">&quot;0&quot;</span><span class="nt">&gt;&lt;/rect&gt;</span>
</span><span class='line'>                <span class="nt">&lt;rect</span> <span class="na">width=</span><span class="s">&quot;200&quot;</span> <span class="na">height=</span><span class="s">&quot;20&quot;</span> <span class="na">fill=</span><span class="s">&quot;blue&quot;</span> <span class="na">y=</span><span class="s">&quot;50&quot;</span><span class="nt">&gt;&lt;/rect&gt;</span>
</span><span class='line'>                <span class="nt">&lt;rect</span> <span class="na">width=</span><span class="s">&quot;300&quot;</span> <span class="na">height=</span><span class="s">&quot;20&quot;</span> <span class="na">fill=</span><span class="s">&quot;blue&quot;</span> <span class="na">y=</span><span class="s">&quot;100&quot;</span><span class="nt">&gt;&lt;/rect&gt;</span>
</span><span class='line'><span class="nt">&lt;/svg&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>There are multiple ways to wire D3 up to a given web framework, but it&rsquo;s ultimately a script that runs to build the component in the DOM. Our old pattern was loosely the following:</p>

<ul>
<li>fetch model in the route</li>
<li>set up component properties in the controller</li>
<li>render the component in the template:</li>
<li>in Ember&rsquo;s <code>didInsertElement</code> hook in the component, run the D3 script that selects body and appends SVG</li>
</ul>


<h4>Made new</h4>


<p>Until recently, we had been able to maintain and reuse our Ember D3 components, but this chat timelines visualization required a brand new D3 component, one we decided to write in React.</p>

<p>My initial instinct, as with simpler React components, was to render the component with properties and run the D3 script in React&rsquo;s <code>render</code> or <code>componentDidMount</code> hook. What became clear, however, was that we didn&rsquo;t need to run the D3 script at all. In place of <code>d3.select(...).append(...)</code> we could simply build up svg elements in the <code>render</code> hook.</p>

<p>This approach, while going against my initial instinct of using D3&rsquo;s pattern, aligns well with React&rsquo;s strengths of one-way data flow and components that are easier to reason about than traditional data binding. It&rsquo;s a declarative approach that expresses what it does, as opposed to an imperative approach that expresses how it&rsquo;s done. And it has benefits of composibility and extensibility&mdash;rather than selecting and appending as additional design specs come in, we can componentize everything&mdash;bars, axes, labels, plots&mdash;to reuse later or modify with greater control.</p>

<p>And that earlier question about data visualizations being written entirely in a framework? Considered this way, we can construct the SVG elements directly in React, something like this:</p>

<figure class='code'><figcaption><span>d3-viz-react.js </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='javascript'><span class='line'><span class="kd">var</span> <span class="nx">D3BarGraph</span> <span class="o">=</span> <span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
</span><span class='line'>        <span class="nx">render</span><span class="o">:</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>                <span class="o">&lt;</span><span class="nx">svg</span> <span class="nx">width</span><span class="o">=</span><span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">props</span><span class="p">.</span><span class="nx">width</span><span class="p">}</span> <span class="nx">height</span><span class="o">=</span><span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">props</span><span class="p">.</span><span class="nx">height</span><span class="p">}</span><span class="o">&gt;</span>
</span><span class='line'>                        <span class="o">&lt;</span><span class="nx">rect</span> <span class="nx">width</span><span class="o">=</span><span class="s2">&quot;100&quot;</span> <span class="nx">height</span><span class="o">=</span><span class="s2">&quot;20&quot;</span> <span class="nx">fill</span><span class="o">=</span><span class="s2">&quot;blue&quot;</span> <span class="nx">y</span><span class="o">=</span><span class="s2">&quot;0&quot;</span><span class="o">&gt;&lt;</span><span class="err">/rect&gt;</span>
</span><span class='line'>                        <span class="o">&lt;</span><span class="nx">rect</span> <span class="nx">width</span><span class="o">=</span><span class="s2">&quot;200&quot;</span> <span class="nx">height</span><span class="o">=</span><span class="s2">&quot;20&quot;</span> <span class="nx">fill</span><span class="o">=</span><span class="s2">&quot;blue&quot;</span> <span class="nx">y</span><span class="o">=</span><span class="s2">&quot;50&quot;</span><span class="o">&gt;&lt;</span><span class="err">/rect&gt;</span>
</span><span class='line'>                        <span class="o">&lt;</span><span class="nx">rect</span> <span class="nx">width</span><span class="o">=</span><span class="s2">&quot;300&quot;</span> <span class="nx">height</span><span class="o">=</span><span class="s2">&quot;20&quot;</span> <span class="nx">fill</span><span class="o">=</span><span class="s2">&quot;blue&quot;</span> <span class="nx">y</span><span class="o">=</span><span class="s2">&quot;100&quot;</span><span class="o">&gt;&lt;</span><span class="err">/rect&gt;</span>
</span><span class='line'>                <span class="o">&lt;</span><span class="err">/svg&gt;</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'><span class="p">});</span>
</span><span class='line'><span class="nx">React</span><span class="p">.</span><span class="nx">render</span><span class="p">(</span><span class="o">&lt;</span><span class="nx">D3BarGraph</span> <span class="nx">width</span><span class="o">=</span><span class="mi">500</span> <span class="nx">height</span><span class="o">=</span><span class="mi">500</span> <span class="nx">data</span><span class="o">=</span><span class="p">{[</span><span class="mi">10</span><span class="p">,</span><span class="mi">20</span><span class="p">,</span><span class="mi">30</span><span class="p">]}</span> <span class="o">/&gt;</span><span class="p">,</span> <span class="nx">mountNode</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>You can pretty quickly see how the inner rectangles could be pulled out as components of their own, as could axes, labels, etc. We&rsquo;ve found this pattern to be much easier to reason about when building visualizations in our UI. So here&rsquo;s to rethinking UI patterns and, as a result, writing code that&rsquo;s easier to reason through.</p>

<h3>Further Resources</h3>


<ul>
<li><a href="http://10consulting.com/2014/02/19/d3-plus-reactjs-for-charting/">D3 and React &ndash; the future of charting components?</a></li>
<li><a href="https://fraserxu.me/2015/06/03/react-data-visualization/">React &amp; Data Visualization</a></li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Scratching My Own Itch: A Chrome Extension Story]]></title>
    <link href="http://cek.io/blog/2015/03/24/chrome-extension/"/>
    <updated>2015-03-24T21:10:39+00:00</updated>
    <id>http://cek.io/blog/2015/03/24/chrome-extension</id>
    <content type="html"><![CDATA[<p>When we submit pull requests on BitBucket, my coworkers and I will generally draw attention when they are net-negative, removing more lines of code than they add. In some cases, it&rsquo;s pretty obvious&mdash;entire files being deleted, etc. Oftentimes, however, it requires doing a bit of mental math to tally the difference between lines added and lines removed. For that reason, it&rsquo;s gratifying to &ldquo;scratch my own itch&rdquo; by installing <a href="https://chrome.google.com/webstore/detail/net-lines-of-code/npjphkppofmfcohiffnkfjnehcaachgf">this extension</a> to do it for me.</p>

<p><img src="http://cek.io/images/chrome_extension.png"></p>

<!--more-->


<p>The &ldquo;problem&rdquo; already had a solution of sorts, in the form of a short jQuery script a coworker had pulled together:</p>

<figure class='code'><figcaption><span> (extension.js)</span> <a href='http://cek.io/downloads/code/chrome-extension/extension.js'>download</a></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='js'><span class='line'><span class="kd">var</span> <span class="nx">addVals</span><span class="p">,</span> <span class="nx">linesAdded</span><span class="p">,</span> <span class="nx">linesRemoved</span><span class="p">,</span> <span class="nx">offset</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="nx">addVals</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">className</span><span class="p">,</span> <span class="nx">symbolToReplace</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>  <span class="kd">var</span> <span class="nx">results</span><span class="p">;</span>
</span><span class='line'>  <span class="nx">results</span> <span class="o">=</span> <span class="p">[];</span>
</span><span class='line'>  <span class="nx">$</span><span class="p">(</span><span class="nx">className</span><span class="p">).</span><span class="nx">each</span><span class="p">(</span><span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">val</span><span class="p">;</span>
</span><span class='line'>    <span class="nx">val</span> <span class="o">=</span> <span class="nx">$</span><span class="p">(</span><span class="k">this</span><span class="p">).</span><span class="nx">html</span><span class="p">().</span><span class="nx">replace</span><span class="p">(</span><span class="nx">symbolToReplace</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">);</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">results</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nb">parseInt</span><span class="p">(</span><span class="nx">val</span><span class="p">));</span>
</span><span class='line'>  <span class="p">});</span>
</span><span class='line'>  <span class="k">return</span> <span class="nx">results</span><span class="p">.</span><span class="nx">reduce</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">x</span> <span class="o">+</span> <span class="nx">y</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="nx">linesAdded</span> <span class="o">=</span> <span class="nx">addVals</span><span class="p">(</span><span class="s1">&#39;.lines-added&#39;</span><span class="p">,</span> <span class="s1">&#39;+&#39;</span><span class="p">);</span>
</span><span class='line'><span class="nx">linesRemoved</span> <span class="o">=</span> <span class="nx">addVals</span><span class="p">(</span><span class="s1">&#39;.lines-removed&#39;</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">);</span>
</span><span class='line'><span class="nx">offset</span> <span class="o">=</span> <span class="nx">linesAdded</span> <span class="o">-</span> <span class="nx">linesRemoved</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure>


<p>A simple solution that, when run in the browser console, would log the offset. I just wanted to make it even simpler by removing that one extra step. That meant setting up a Chrome extension, which was a far easier process than I thought it might be.</p>

<h3>A brief how-to</h3>




<ul>
  <li>Set up a new directory with a <code>manifest.json</code> file, with a <code>name</code>, <code>manifest_version</code> of 2, a <code>version</code>, </li>
  <li>To see it working, add an icon.png and list that file in <code>manifest.json</code> under <code>browser_action.default_icon</code>. By now, <code>manifest.json</code> should look something like this:
  <div>
  <pre><code class='javascript'>{
    &quot;name&quot;: &quot;Hello World!&quot;,
    &quot;manifest_version&quot;: 2,
    &quot;version&quot;: &quot;1.0&quot;,
    &quot;description&quot;: &quot;My first Chrome extension.&quot;,
    &quot;browser_action&quot;: {
      &quot;default_icon&quot;: &quot;icon.png&quot;
    }
  }</code></pre>
</div>

  </li>
  <li>Go to <a href="chrome://extensions">chrome://extensions</a>, tick &#8216;developer mode&#8217;, click &#8216;load unpacked extension&#8217;, and select your new folder&#8211;note your icon appear in the top right of your browser, next to your other extensions.</li>
  <li>At this point, you have a Chrome extension! Of course, now you need to decide what you want it to do, but getting it started is that trivial. In my case, I didn&#8217;t even keep the default icon, since I just want a script to run on certain domains.</li>
  <li>Publishing the extension requires a <a href="https://chrome.google.com/webstore/developer/dashboard">Chrome developer account</a> (which requires a $5 payment), which you can set up here. From there, publishing the extension just requires compressing the folder to a zip file (right-click the folder, compress) and uploading.</li>
</ul>




<h3>Resources</h3>


<p><a href="https://developer.chrome.com/extensions/getstarted">Google&rsquo;s documentation is pretty clear and helpful</a><br>
<a href="http://lifehacker.com/5857721/how-to-build-a-chrome-extension">Lifehacker has a decent intro tutorial.</a><br></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Old and New Years]]></title>
    <link href="http://cek.io/blog/2015/01/03/new-year/"/>
    <updated>2015-01-03T17:14:20+00:00</updated>
    <id>http://cek.io/blog/2015/01/03/new-year</id>
    <content type="html"><![CDATA[<p>Happy new year! A resolution of mine for 2015 is to write more&mdash;not just code, which is itself an admirable goal, but human-readable English. This was motivated by (1) the advice in <a href="http://www.shubhro.com/2014/12/27/software-engineers-should-write/">this article</a> I read recently, which is <a href="http://bit.ly/1K9MAZk">not new advice</a>, (2) the hope that, for all the benefits of specialization, there&rsquo;s value in maintaining competence in both programming and verbal language, and (3) the fact that I like writing! So you can expect more consistent posts than the last six months have yielded.</p>

<p>My commitment to blog is also part of a larger goal: to further establish myself as a software engineer, which means (among other things like improving my technical skills) better understanding the industry. Recognizing my ignorance about computer science and its history, I put <a href="http://www.nytimes.com/2014/10/09/arts/walter-isaacsons-the-innovators-studies-computer-wizards.html">Walter Isaacson&rsquo;s &ldquo;The Innovators&rdquo;</a> on my Christmas wishlist.</p>

<p>I&rsquo;m only two chapters in, but I&rsquo;m already struck by two major things: (1) the main thesis arguing that innovation is more attributable to collaboration than to singular genius and (2) the convergence of technological advances in the year 1937, all of which accelerated towards the modern computer.</p>

<!--more-->


<p>Isaacson writes:</p>

<blockquote><p>New approaches, technologies, and theories began to emerge in 1937&#8230; It would become an annus mirabiliis of the computer age, and the result would be the triumph of four properties, somewhat interrelated, that would define modern computing.</p><footer><strong>Walter Isaacson</strong> <cite>The Innovators (38)</cite></footer></blockquote>


<p>He defines those four computing properties as digital, binary, electronic, and general purpose, and he summarizes the following key individuals and their contributions in (and around) 1937:</p>

<table>
<thead>
<tr>
<th></th>
<th> Person(s)                                         </th>
<th> Contribution         </th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td> Alan Turing (Cambridge/Princeton)                 </td>
<td> Published paper of mathematical theory (addressing Hilbert&rsquo;s <em>Entscheidungsproblem</em>), with the byproduct of the conceptual &ldquo;Logical Computing Machine&rdquo;, which became known as the Turing Machine (&ldquo;It is possible to invent a single machine which can be used to compute any computable sequence&rdquo;).</td>
</tr>
<tr>
<td></td>
<td> Claude Shannon and George Stibitz (Bell Labs)     </td>
<td> Shannon figured out that electrical circuits could execute Boolean logical operations using an arrangement of on-off switches. Stibitz built the Complex Number Calculator which, based on Shannon&rsquo;s insight, showed the potential of circuit relays to do binary math, process information, and handle logical procedures.</td>
</tr>
<tr>
<td></td>
<td> Howard Aiken (Harvard)                            </td>
<td> Began plans on the Mark I which, when completed in 1944 under IBM and the Navy, was fully automatic&mdash;it could run for days without human intervention&mdash;as well as digital (though non-binary and partially mechanical).</td>
</tr>
<tr>
<td></td>
<td> Konrad Zuse (Berlin)                              </td>
<td> Finished a calculator prototype, the Z1, that was binary and could read instructions from a punched tape (though mechanical). This ultimately gave way to the Z3, which was the first fully working all-purpose, programmable digital computer.</td>
</tr>
<tr>
<td></td>
<td> John Vincent Atanasoff (Ames, Iowa)               </td>
<td> Conceived the first partly electronic digital computer, which solved linear equations. It used mechanically rotating cylinders to replenish electrical charges in condensers and thus maintain memory. Atanasoff was also (disputedly) the inspiration for John Mauchly&rsquo;s work.</td>
</tr>
<tr>
<td></td>
<td> John Mauchly and J. Presper Eckert (UPenn, 1940s) </td>
<td> With funding from the US War Department, built ENIAC (the Electronic Numerical Integrator and Computer). ENIAC was digital computer using the decimal (not binary) system, which could handle conditional branching and subroutines.</td>
</tr>
</tbody>
</table>


<br>


<p>Incredible how much took place&mdash;or was at least initiated&mdash;over the course of a single year, and telling that the contributions that persisted were ones of collaboration, whether as partnerships of key individuals (e.g., Turing, Max Newman, and Alonzo Church) or in settings with collaborative resources (e.g., Bell Labs and major universities). Without diminishing their significance, those lone innovators were ultimately unable to mark history in the same way (e.g., Atanasoff, whose prototype was forgotten and dismantled, or Zuse, whose work with a single college friend was interrupted and lost when he was pulled into engineering airplanes for the German military).</p>

<p>As we head into this new year, I can only hope 2015 will be half as innovative as 1937, and that I can apply those lessons of collaboration to my blog and my continued growth as a developer.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Should You Ever Edit Your Gemfile.lock? (No...But Maybe Sometimes...Conservatively)]]></title>
    <link href="http://cek.io/blog/2014/07/23/edit-gemfile-dot-lock/"/>
    <updated>2014-07-23T15:19:30+01:00</updated>
    <id>http://cek.io/blog/2014/07/23/edit-gemfile-dot-lock</id>
    <content type="html"><![CDATA[<p>When developing a Rails app, should you ever edit your Gemfile.lock? Easy answer: it&rsquo;s no, right? <a href="http://stackoverflow.com/a/11136025/3166243">Plenty</a> <a href="http://codedecoder.wordpress.com/2013/01/02/difference-gemfile-lock-rails/">of</a> <a href="http://asciicasts.com/episodes/201-bundler">reputable</a> <a href="http://codelikethis.com/lessons/ruby_tools/bundler">sources</a> all seem to discourage it. I myself gave that answer when asked recently. But I&rsquo;ve come to learn that the answer is not a complete cut-and-dried &ldquo;no&rdquo;, at least not in certain circumstances.</p>

<!--more-->




<h3>Some background</h3>


<p>How does the Gemfile work? A quick refresher:</p>

<ul>
  <li>
    The Gemfile is a list of all gems that you want to include in the project. It is used with bundler to install, update, remove and otherwise manage your used gems.
  </li>
  <li>
    <a href="http://bundler.io/">Bundler</a> &#8220;provides a consistent environment for Ruby projects by tracking and installing the exact gems and versions that are needed. Bundler is an exit from dependency hell, and ensures that the gems you need are present in development, staging, and production. Starting work on a project is as simple as bundle install.&#8221;
  </li>
  <li>
    Simply put, we list our gems and dependencies in the Gemfile, run <code>bundle install</code>, a Gemfile.lock is generated, and our dependencies are taken care of. Right?
  </li>
</ul>




<h3>What happens when we <code>bundle install</code>?</h3>


<p>Quoting the bundler documentation:</p>

<blockquote><p>Install the gems specified in your Gemfile. If this is the first time you run bundle install (and a Gemfile.lock does not exist), bundler will fetch all remote sources, resolve dependencies and install all needed gems.</p><p>If a Gemfile.lock does exist, and you have not updated your Gemfile, bundler will fetch all remote sources, but use the dependencies specified in the Gemfile.lock instead of resolving dependencies.</p><p>If a Gemfile.lock does exist, and you have updated your Gemfile, bundler will use the dependencies in the Gemfile.lock for all gems that you did not update, but will re-resolve the dependencies of gems that you did update.</p><footer><strong>Bundler.io</strong> <cite><a href='http://bundler.io/v1.6/man/bundle-install.1.html'>Bundle-install</a></cite></footer></blockquote>


<p>No surprises here. This fits with the general understanding of Bundler and Gemfiles. But keep this in mind as you continue below, since the resolving of dependencies may mean more than you realize.</p>

<h3>Introducing some controversy: conservative gem updates</h3>


<p>Imagine this situation:
You run <code>bundle update cucumber-rails</code>, thinking it will only update <code>cucumber-rails</code>. In fact, this actually updates not just <code>cucumber-rails</code>, but all of its dependencies as well, which will explode in your face when one of these dependencies release a new version with breaking API changes. This happens all too often.</p>

<p>Lest you think I&rsquo;m all alone in this, know that I&rsquo;m pulling the above example from <a href="http://makandracards.com/makandra/13885-how-to-update-a-single-gem-conservatively">this post from Makandra Cards</a>, and the idea in general from more experienced developers than myself. The author of the post suggests three options for conservative gem updates, the first of which is to make changes directly to Gemfile.lock.</p>

<p>Crazy, right? Controversial, even? Perhaps not. To date, Bundler has not acknowledged <a href="https://github.com/bundler/bundler/issues/2016">this issue</a>, but there&rsquo;s a significant use case (edge case, perhaps) that calls for editing Gemfile.lock. Just do it conservatively. Everything in moderation.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Intro to JavaScript (According to Douglas Crockford)]]></title>
    <link href="http://cek.io/blog/2014/07/21/intro-to-javascript-crockford/"/>
    <updated>2014-07-21T17:21:55+01:00</updated>
    <id>http://cek.io/blog/2014/07/21/intro-to-javascript-crockford</id>
    <content type="html"><![CDATA[<p><strong>Summary</strong>: I&rsquo;m working my way through a few <a href="https://github.com/bolshchikov/js-must-watch">must-watch videos about JavaScript</a>. If you know JavaScript, pretend to know JavaScript, or hope to learn JavaScript, check out those videos. Or read this and the <a href="http://cek.io/blog/2014/07/21/javascripts-historical-context-crockford">previous post</a> (and save yourself three hours of video-watching), in which I pull some of my favorite quotes from what <a href="https://en.wikipedia.org/wiki/Douglas_Crockford">Douglas Crockford</a> has to say about JavaScript.</p>

<p><strong>Notes</strong>: The quotes below represent some of the key statements (as I judge them) in order of their appearance in Crockford&rsquo;s <a href="http://youtu.be/RO1Wnu-xKoY">second talk</a> on JavaScript. Read together, they outline the main trajectory of Crokford&rsquo;s presentation, but they are not intended to replace the entirety of the talk.</p>

<h3>Crockford on JavaScript&#8217;s key features</h3>


<p><u><h5>JavaScript: The Bad Parts</h5></u>
&ldquo;Since I discovered that the language had good parts, that sort of implies that it must have had bad parts. Why would anybody design a language with bad parts? How would that come about? In my review of all the bad parts in the language, it mostly comes from <strong>three causes</strong>. The first is <strong>legacy</strong>. In copying the Java syntax, JavaScript also copied some bad things about Java, so many of the worst features in JavaScript are actually things it inherited from Java, which it inherited from C, which it inherited from FORTRAN. So there’s a long line of sin-age which affects us today.</p>

<p>&ldquo;There were some <strong>good intentions</strong> in the language that didn’t quite work out. Things were added, like semi-colon insertion and implied global variables, with the intention of making the language easier to use for beginners. In fact, it worked, because it turns out that if you have absolutely no idea what you’re doing in the language you can still generally make things work. Unfortunately, those things work against professional programmers trying to do large, sophisticated programs, so there are some trade-offs there that didn’t work out well for us.</p>

<p>&ldquo;But the biggest influence, by far, was <strong>haste</strong>. The language was designed, implemented, and shipped in way too little time. Most languages take years to develop – for example, Smalltalk was eight years from Alan Kay’s first prototype to Smalltalk 80, when it was first made available to the public. That’s a good timeframe for a programming language, because you want to go through it and test it, make sure that it works, and refine it in order to make sure that it’s meeting its goals. JavaScript was prepared in about as many days.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=12m22s">Link</a>)</p>

<!--more-->


<p><u><h5>JavaScript: The Good Parts</h5></u>
&ldquo;The good news is that, for the most part, the bad parts can be avoided. And if you avoid the bad parts, and if you work just with what’s left over, <a href="http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742">the good parts</a>, there’s actually a brilliant language there. The features that were selected and the way that they were put together is astonishingly good. It’s a language of amazing expressive power. JavaScript is a language that most people don’t bother to learn before they use. You can’t do that with any other language, and you shouldn’t want to, and you shouldn’t do that with this language either. Programming is a serious business, and you should have good knowledge about what you’re doing, but most people feel that they ought to be able to program in this language without any knowledge at all, and it still works. It’s because the language has enormous expressive power, and that’s not by accident. <strong>There’s actually some brilliant design in there</strong>.</p>

<p>&ldquo;The problem with the bad parts isn’t that they’re useless, it’s that they’re dangerous. I see a lot of wannabe ninjas out there who are going through the bad parts and going ‘oh, I found a new use for with, or another thing you can do with eval,’ or some other edge case. Stop doing that. Stop doing that!&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=14m44s">Link</a>)</p>

<p><u><h5>Object-Oriented JavaScript</h5></u>
&ldquo;<strong>This language is all about objects; it’s an object oriented language</strong>. I’ll try to demonstrate to you that it is more object oriented than Java. For a long time, a lot of the opinion about this language was that it’s not object oriented, it’s object based, it’s deficient. It turns out it’s actually a superior language.</p>

<p>&ldquo;<strong>In this language, an object is a dynamic collection of properties. This is quite different than in most of the other object oriented languages in which an object is an instance of a class, where a class has some state and behavior. Objects in this system are much more dynamic</strong>. So it’s a collection of properties, and each property has a keystring which is unique within that object. If you add two properties with the same name, the second one will replace the first one.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=16m1s">Link</a>)</p>

<p><u><h5>JavaScript accessor property (getter/setter)</h5></u>
&ldquo;Here’s an example of using an <strong>accessor property</strong>. The difference between an accessor property and a data property is that an accessor property uses get and/or set. Here I’m defining a property for my object called inch. When I try to get inch, my_object, ’Inch’, I will receive the result of dividing this.mm by 25.4. If I try to set it, I won’t actually set this property, instead I will set millimeter to whatever value I pass times 25.4. So the result of this is that I can have an object with two properties in it that are linked in an interesting constraint way. I can set either the millimeters or the inch and it will appear to fix the other one, so I can keep those two things in sync. There are a lot of really interesting patterns that can be done with these. There are even more evil patterns that can be done with this.</p>

<p>&ldquo;For example, one of the assumptions that you’ve always had in the language was that you can go to an object and retrieve a property and there’s no transfer of control, you’re just getting some data. Now you’re giving control over to a function which you hope will give it back, but it might not. But it can also mutate the object while it’s getting the thing, so something that used to be a read-only event is now potentially a mutating event which could mutate this object or who-knows-what in the thing. So there are all sorts of really abusive patterns that can be made out of these getters and setters, and I recommend to all the ninjas: don’t get stupid with stuff, because it’s going to be really, really easy to get stupid with this stuff. I’m telling you, you can get stupid with this stuff, and you don’t need to do it. So be smart with this. Use it sparingly.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=21m22s">Link</a>)</p>

<p><strong>Example:</strong></p>

<figure class='code'><figcaption><span>Accessor property</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='javascript'><span class='line'><span class="nx">myObject</span> <span class="o">=</span> <span class="p">{};</span>
</span><span class='line'>
</span><span class='line'><span class="nb">Object</span><span class="p">.</span><span class="nx">defineProperty</span><span class="p">(</span><span class="nx">myObject</span><span class="p">,</span> <span class="s1">&#39;inch&#39;</span><span class="p">,</span> <span class="p">{</span>
</span><span class='line'>  <span class="nx">get</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">mm</span> <span class="o">/</span> <span class="mf">25.4</span><span class="p">;</span>
</span><span class='line'>  <span class="p">},</span>
</span><span class='line'>  <span class="nx">set</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">value</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">this</span><span class="p">.</span><span class="nx">mm</span> <span class="o">=</span> <span class="nx">value</span> <span class="o">*</span> <span class="mf">25.4</span><span class="p">;</span>
</span><span class='line'>  <span class="p">},</span>
</span><span class='line'>  <span class="nx">enumerable</span><span class="o">:</span> <span class="kc">true</span>
</span><span class='line'><span class="p">});</span>
</span><span class='line'>
</span><span class='line'><span class="nx">myObject</span><span class="p">.</span><span class="nx">inch</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
</span><span class='line'><span class="nx">myObject</span><span class="p">;</span>
</span><span class='line'>  <span class="c1">//  returns { inch: [Getter/Setter], mm: 254 }</span>
</span></code></pre></td></tr></table></div></figure>


<p><u><h5>Classes vs. Prototypes (prototypes!)</h5></u>
&ldquo;The most controversial feature of the language is the way it does inheritance, which is radically different than virtually all other modern languages. <strong>Most languages use classes – I call them ‘classical languages’ – JavaScript does not. JavaScript is class free. It uses prototypes.</strong> For people who are classically trained who look at the language, they go: well, this is deficient. You don’t have classes, how can you get anything done? How can you have any confidence that the structure of your program’s going to work? And they never get past that.</p>

<p>&ldquo;But it turns out classes as we currently understand them were first formulated in 1967, in Simula. The prototypal school was developed about 20 years later, at Xerox Parc, by people who had intimate knowledge of Smalltalk, which was the first modern semi-popular object oriented programming language. <strong>The changes that they made were not made in ignorance; it was very well informed, changing, simplifying, and advancing the programming model. And what they did was they created, in my view, a vast improvement over the model that had come before</strong>.</p>

<p>&ldquo;It’s possible that one demonstration of the greater power of the new thing is that, first off, <strong>code is smaller</strong>. If you’re writing to the prototypal model and you’re doing it correctly, your programs are a lot smaller. For one thing, you take out a lot of the silly redundancy, like &lsquo;I’m creating a variable of this type named That Type, initialized with new That Type.&rsquo; You’re saying everything three times, and you tend not to do that in a prototypal language. But more than that, <strong>you can simulate the classical language in the prototypal language</strong>. You can’t do the other. Java is not powerful enough that you can write in a JavaScript style in Java; it’s just not good enough. JavaScript is, so you can do it the other way around, because<strong> it’s the more powerful of the models</strong>.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=24m8s">Link</a>)</p>

<p><u><h5>Object.create (don&rsquo;t use <code>new</code>)</h5></u>
&ldquo;I don’t use new anymore. I don’t need it. I’m thinking prototypally now, and when I’m thinking prototypally I can do everything I want to do with object.create. So I see this now as just a vestige; I don’t need it anymore. There’s also a hazard with new, that if you design a constructor that’s supposed to be used with new and either you, or one of your users, forgets to put the new prefix on it, instead of initializing a new object the instructor’s going to be clobbering the global object, damaging global variables and not doing useful work at all, and there’s no compile time warning or runtime warning of that. That’s a feature I don’t need to use.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=31m26s">Link</a>)</p>

<p><u><h5>Functions and objects</h5></u>
&ldquo;<strong>The best feature in the language, the good parts, the very best parts, are functions</strong>. We’ll talk about them <a href="https://www.youtube.com/watch?v=ya4UHuXNygM">next time</a>. So that’s all the objects. All the values in this language are objects, with two exceptions: null, and undefined.&rdquo; (<a href="">Link</a>)</p>

<p><u><h5>JavaScript and C</h5></u>
&ldquo;Syntactically, <strong>JavaScript is clearly a member of the C family of programming languages</strong>. It’s got the curly braces and all of that stuff. It differs from C mainly in its type system, which allows functions to be values.&rdquo; (<a href="">Link</a>)</p>

<h3>Resources</h3>


<p><a href="http://youtu.be/RO1Wnu-xKoY">Crockford on JavaScript &ndash; Chapter 2: And Then There Was JavaScript [Video]</a><br>
<a href="http://abraham.cs.uml.edu/~heines/91.461/resources/CrockfordOnJavaScript/crockonjs-2-transcript.pdf">Crockford on JavaScript &ndash; Chapter 2: And Then There Was JavaScript [Full transcript]</a><br></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[JavaScript's Historical Context (According to Douglas Crockford)]]></title>
    <link href="http://cek.io/blog/2014/07/21/javascripts-historical-context-crockford/"/>
    <updated>2014-07-21T15:01:39+01:00</updated>
    <id>http://cek.io/blog/2014/07/21/javascripts-historical-context-crockford</id>
    <content type="html"><![CDATA[<p><strong>Summary</strong>: I&rsquo;m working my way through a few <a href="https://github.com/bolshchikov/js-must-watch">must-watch videos about JavaScript</a>. If you know JavaScript, pretend to know JavaScript, or hope to learn JavaScript, check out those videos. Or read this and the <a href="http://cek.io/blog/2014/07/21/intro-to-javascript-crockford">following post</a> (and save yourself three hours of video-watching), in which I pull some of my favorite quotes from what <a href="https://en.wikipedia.org/wiki/Douglas_Crockford">Douglas Crockford</a> has to say about JavaScript.</p>

<p><strong>Notes</strong>: The quotes below represent some of the key statements (as I judge them) in order of their appearance in Crockford&rsquo;s <a href="http://youtu.be/JxAXlJEmNMg">first</a> and <a href="http://youtu.be/RO1Wnu-xKoY">second</a> talks on JavaScript. Read together, they outline the main trajectory of Crokford&rsquo;s presentation, but they are not intended to replace the entirety of the talk. The first 50 minutes of the first talk, which cover the history of programming before 1970, are excluded from this post, not because they&rsquo;re unimportant (they are!), but because it was difficult to pull single quotes that represented the content. All emphases mine.</p>

<h3>Crockford on JavaScript&#8217;s historical context, distilled into key quotes</h3>


<p><u><h5>Innovation since the &lsquo;70s</h5></u>
&ldquo;The other thing we&rsquo;ve seen is an end to CPU innovation. <strong>We used to see a lot of really radical new designs happening all the time, but we don&rsquo;t see that happening anymore</strong>. Basically we&rsquo;ve got three architectures that we use for most of our stuff: virtually all the computers are on Intel, most of the game platforms are on Power PCs, most of the mobile devices are on ARM, and that&rsquo;s it. Nobody&rsquo;s making new stuff, nothing radical, it&rsquo;s just refinements of stuff that&rsquo;s been happening for several decades.</p>

<p>&ldquo;We&rsquo;re doing even worse in operating systems. It used to be that every model of every machine had its own operating system, and that came with a lot of obvious inefficiency, so we&rsquo;ve pushed that down and now we have just two: we&rsquo;ve got Unix which was developed in the &lsquo;70s, and we&rsquo;ve got Windows that was developed in the &#8217;80s. Of the two, Unix is obviously the better one, but there&rsquo;s no innovation happening in operating systems. Basically we&rsquo;ve been rewriting the same systems for 40 years. That&rsquo;s just not where we do innovation. <strong>Where we do innovation is in programming languages, and that&rsquo;s been going on for quite a long time.</strong>&rdquo;  (<a href="http://youtu.be/JxAXlJEmNMg?t=56m50s">link</a>)</p>

<!--more-->


<p><u><h5>Leaps</h5></u>
&ldquo;Software development comes in leaps, and our leaps are much farther apart than the hardware experiences. Moore&rsquo;s Law lets the hardware leap every two years; we leap more like every twenty years. Again, <strong>basically we need a generation to retire before we can get the good new ideas going</strong>, so despite the fact that we&rsquo;re always talking about innovation and how we love innovation and we&rsquo;re always innovating, <strong>we tend to be extremely conservative in the way we adopt new technology</strong>.&rdquo; (<a href="http://youtu.be/JxAXlJEmNMg?t=1h21m5s">Link</a>)</p>

<p><u><h5>The beginning of JavaScript</h5></u>
&ldquo;Basically, [<a href="https://en.wikipedia.org/wiki/Brendan_Eich#CEO_appointment_and_resignation">Brendan Eich</a>] took these components: he took the <strong>syntax of Java</strong>, he took <strong>the function model of Scheme</strong>&mdash;which was brilliant, one of the best ideas in the history of programming languages&mdash;and he took <strong>the prototype objects from Self</strong>. He put them together in a really interesting way, really fast; he completed the whole thing in a couple of weeks. It&rsquo;s a shame that he wasn&rsquo;t given the freedom that Xerox had to spend a decade to get this right. Instead of ten years it was more like ten days, and that was it. I challenge any language designer to come up with a brand new design from scratch in ten days and then release it to the world and call it done and see what happens with that.</p>

<p>&ldquo;One of the consequences of it was that there are parts of it that are just awful. If they&rsquo;d had more time they probably would have recognized that and fixed it, but they didn&rsquo;t. Netscape was not a company that had time to get it right, which is why there&rsquo;s no longer a Netscape.</p>

<p>&ldquo;But despite that, <strong>there is absolutely deep profound brilliance in this language, and this language is succeeding in places where many other languages have failed because of that brilliance; it&rsquo;s not accidental that JavaScript has become the most popular programming language in the world</strong>.&rdquo; (<a href="http://youtu.be/JxAXlJEmNMg?t=1h37m34s">Link</a>)</p>

<p><u><h5>A great time to be a programmer</h5></u>
&ldquo;One thing that&rsquo;s different now than in the &lsquo;50s and &#8217;60s is there are lot of computers out there, and there are a lot of people writing programs now. It&rsquo;s possible to get a <strong>community of people</strong> even if you have a minor language, enough to do useful things, to do a lot of group work. You&rsquo;ve got a group large enough to justify writing books, which was something we didn&rsquo;t have back in the &#8217;50s and &#8217;60s. So I think <strong>this is a great time to be a programmer</strong>. We have lots of choices, and we need to be smart about making those choices and be open to accepting the new ideas, because there are a lot of new ideas out there that we shouldn&rsquo;t be rejecting just because they&rsquo;re unfamiliar and we don&rsquo;t see the need for them. There are actually a lot of good ideas in all of these languages, not least of which is JavaScript&hellip;&rdquo; (<a href="http://youtu.be/JxAXlJEmNMg?t=1h40m44s">Link</a>)</p>

<p><u><h5>Mythology of innovation</h5></u>
&ldquo;Now, if you were here last time you’ll remember I went through the history of everything that ever happened, starting with The Big Bang, going through The Dawn of Man, and then finally there was JavaScript. The reason I did that was because understanding the context in which this stuff happens is really important to understanding what we have now. Without that understanding you’re consumed by <strong>mythology which has no truth in it</strong>, that the history of innovation has been one thing after another where the new, good thing always displaces the old stuff. That’s not how it works, generally. <strong>Generally the most important new innovations are received with contempt and horror and are accepted very slowly, if ever</strong>. That’s an important bit of knowledge to have, in the case of JavaScript.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=18s">Link</a>)</p>

<p><u><h5>JavaScript has good parts</h5></u>
&ldquo;Having that background [understanding history and innovation] allowed me to make the first important discovery of the 21st century, which was that <strong>JavaScript has good parts</strong>. This was an <strong>unexpected discovery</strong>, and when I tried to share it with the rest of the community there was a huge amount of skepticism; a lot of people refused to believe it was possible that JavaScript had any redeeming value whatsoever. In fact, it has very, very good parts. But I’m getting a little ahead of the story, so let’s back up a little bit.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=1m44s">Link</a>)</p>

<p><u><h5>Why it&rsquo;s called JavaScript (Netscape-Sun history)</h5></u>
&ldquo;It was very clear at the time that there was a lot of excitement about Java and the Netscape browser, and Sun and Netscape decided they needed to work together against Microsoft because if they didn’t join forces Microsoft would play them off against each other and they’d both lose. The biggest point of contention in that arrangement was what to do with LiveScript. Sun’s position was: &#8220;Well, we’ll put Java into the Netscape browser, we’ll kill LiveScript, and that’ll be that.&rdquo; And Netscape said no, that they really believed in the HyperCard-like functionality, and they wanted a simpler programming model in order to capture a much larger group of programmers.</p>

<p>&ldquo;So there was an impasse, and the relationship almost broke up, when I think Marc Andreessen&mdash;and I have been able to document this, but <strong>people have told me&mdash;Marc Andreessen, maybe as a joke, suggested: &lsquo;let’s change the name to JavaScript.&rsquo; And it worked</strong>! Except that Sun claimed ownership of the trademark. Even though they had nothing to do with the language and they tried to kill the language, they said ‘we own the trademark, but we’ll give you a license to use the trademark’. Netscape said &lsquo;great, an exclusive license, only we can call it JavaScript, that’s fine&rsquo;.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=7m4s">Link</a>)</p>

<p><u><h5>The destruction of Microsoft</h5></u>
&ldquo;At Microsoft they’d been watching this with some alarm, particularly when folks at Netscape were saying that Netscape Navigator was going destroy Microsoft. Microsoft said ‘oh, we don’t want to be destroyed’. It turned out Netscape Navigator didn’t destroy Microsoft. In fact, <strong>the software that is going to destroy Microsoft is Windows Mobile</strong>.&rdquo; (<a href="http://youtu.be/RO1Wnu-xKoY?t=8m28s">Link</a>)</p>

<p><u><h5>JavaScript naming confusion</h5></u>
&ldquo;What should we call the language? There’s a lot of confusion. Some people still think that JavaScript, JScript, and ECMAScript are three different languages, and that’s not the case. It’s three silly names for one silly language. JavaScript isn’t actually an open name, which is surprising in that this is the language of the world’s biggest open system. It’s a trademark now of Oracle, and we don’t know what they’re going to do with that. We probably should call it ECMAScript, except it’s such an awful thing to call it.&rdquo;</p>

<h3>Resources</h3>


<p><a href="http://youtu.be/JxAXlJEmNMg">Crockford on JavaScript &ndash; Volume 1: The Early Years [Video]</a><br>
<a href="https://teaching.cs.uml.edu/~heines/91.461/resources/CrockfordOnJavaScript/crockonjs-1-transcript.pdf">Crockford on JavaScript &ndash; Volume 1: The Early Years [Full transcript]</a><br>
<a href="http://youtu.be/RO1Wnu-xKoY">Crockford on JavaScript &ndash; Chapter 2: And Then There Was JavaScript [Video]</a><br>
<a href="http://abraham.cs.uml.edu/~heines/91.461/resources/CrockfordOnJavaScript/crockonjs-2-transcript.pdf">Crockford on JavaScript &ndash; Chapter 2: And Then There Was JavaScript [Full transcript]</a><br></p>
]]></content>
  </entry>
  
</feed>