atom.xml

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

  <title><![CDATA[Thoughts & Technical Writings.]]></title>
  <link href="http://mattcampbell.nyc/atom.xml" rel="self"/>
  <link href="http://mattcampbell.nyc/"/>
  <updated>2017-03-04T15:13:16-05:00</updated>
  <id>http://mattcampbell.nyc/</id>
  <author>
    <name><![CDATA[Matt Campbell]]></name>
    <email><![CDATA[mecampbell25@gmail.com]]></email>
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[Responses to Bitcoin's Diversity of Use-Cases and Security Models]]></title>
    <link href="http://mattcampbell.nyc/2017/03/04/responses-to-bitcoins-diversity-of-use-cases-and-security-models/"/>
    <updated>2017-03-04T15:01:41-05:00</updated>
    <id>http://mattcampbell.nyc/2017/03/04/responses-to-bitcoins-diversity-of-use-cases-and-security-models</id>
    <content type="html"><![CDATA[<p>Original post: <a href="http://bluematt.bitcoin.ninja/2017/02/28/bitcoin-trustlessness/">http://bluematt.bitcoin.ninja/2017/02/28/bitcoin-trustlessness/</a></p>

<blockquote><p>While there is arguably some trust in miners required to ensure the entirety of the blockchain isn’t reorganized</p></blockquote>

<p>Why are you singling out miners? The 51% attack vector is neither exclusive to nor more likely to be pursued by miners. Anyone can incur the PoW cost to mine an alternative version of history (alternative blockchain) and propagate those blocks to nodes. In fact, I would argue that miners are less likely than non-miners to pursue a 51% attack since they are in an extremely competitive business.</p>

<blockquote><p>Of course to ensure you aren’t trusting miners and pools to secure their operations perfectly</p></blockquote>

<p>What does this mean? If your point is that one should wait for <code>n</code> confirmations before assuming your transaction is valid, that is incorrect. Miners have no role in validating transactions (full nodes do that); they just choose which already-validated transactions should be put in the next block. If they try to put invalid transactions in a block, then that block will be rejected and their mining reward foregone.</p>

<blockquote><p>Clearly a payment system which requires a week or more for payment to clear would not be able to compete with much faster alternatives.</p></blockquote>

<p>This is not an apples to apples comparison. Many people seem to want to compare Bitcoin to Visa, but that is a trap. After SegWit is activated, Bitcoin will <em>enable</em> a trustless, instantaneous and secure peer-to-peer payment network like Lightning, but Bitcoin itself will never be that payment network by design. Acheiving decentralized consensus via PoW and fully-validating nodes requires a massive amount of redundant messaging to propagate throughout the network, which is not a design that lends itself to high throughput for the network at large.</p>

<blockquote><p>Many investors who care strongly about Bitcoin’s scarcity properties are happy to trust centralized third-parties in the form of Bitcoin exchanges and “Bitcoin banks”.</p></blockquote>

<p>That trust is misplaced. They should not keep coins at an exchange (see: all the exchange hacks) and should certainly not get anywhere near something called a &ldquo;Bitcoin bank&rdquo; since in Bitcoin users <em>are</em> their own bank. Bitcoin is all about financial disintermediation.</p>

<blockquote><p>Many Bitcoin users who want fast payments for medium- to small-value transactions are happy to trust miners, in sufficient measure.</p></blockquote>

<p>In what way are they trusting miners? Again, miners do not validate transactions, they just decide which transactions to put in the next block.</p>

<blockquote><p>Such trust relationships, as long as users aren’t forced into them (either by explicit requirement or sufficiently strong financial incentive), can provide significantly better user experience through faster, cheaper, and more user-friendly transactions.</p></blockquote>

<p>Aren&rsquo;t you saying that users <em>choose</em> such a trusted relationship? One would think they do this because of a strong financial incentive, e.g. 0 confirmations at one time was considering a value-add feature for payment processors to attract users, but the payment processor would have to trust the user to not double spend. Can you give an example of what you&rsquo;re describing in this paragraph?</p>

<blockquote><p> (eg trusting miners or developers to keep the 21 million Bitcoin limit)</p></blockquote>

<p>Neither of these make sense to me. Developers do not own the monopology on total number of Bitcoins in circulation, clearly. What does &lsquo;trusting miners&rsquo; mean?</p>

<blockquote><p>Bitcoin must only change by consensus of its ever-growing userbase.</p></blockquote>

<p>Bitcoin <em>is</em> consensus, and that consensus is determined by the software being run primarily by fully-validating nodes, and additionaly to some extent by miners &amp; wallets/clients which relay new transactions to the network. Bitcoin does not care about whether or not people agree or not.</p>

<blockquote><p>Putting all of this together we see a picture of where Bitcoin must evolve if it wants to retain its trustless properties while providing a usable system for its many, vastly divergent, use-cases.</p></blockquote>

<p>That step in the evolutino is already here and it&rsquo;s called SegWit. So, run a SegWit full node and help us move towards that vision.</p>

<blockquote><p>or even a trusted “Bitcoin bank”.</p></blockquote>

<p>This is not one of the divergent use cases you mention that are relevant or specific to Bitcoin. If you want to trust a 3rd party, you don&rsquo;t need (and shouldn&rsquo;t use) Bitcoin.</p>

<blockquote><p>Users which do not even want to trust miners should be free to do so, placing their transactions on the blockchain and waiting weeks to ensure even future hashpower attacks will not reverse them</p></blockquote>

<p>What? I&rsquo;m lost. By &ldquo;placing their transactions on the blockchain&rdquo; are you talking about running one&rsquo;s own mining equipment? And, again, you aren&rsquo;t trusting miners. Miners expend energy to perform proof-of-work; an attacker trying to double spend needs to <em>redo</em> all of the work beteween (a) the block that includes the double spend transaction(s), and (b) the most recent block in the chain.</p>

<blockquote><p>the community of Bitcoin users must continue to enforce that changes happen only through consensus among the ever-broadening group</p></blockquote>

<p>What community? Whom are you addressing? Bitcoin is about <em>software running on machines</em>, not people&rsquo;s opinions about what is good or bad for Bitcoin.</p>

<blockquote><p>Critically, this means that all changes which do not harm the utility of Bitcoin for any of its many use-cases, while helping others, should be made, wherever possible.</p></blockquote>

<p>This is the exact thing people are disagreeing about currently vis-a-vis SegWit. And since SegWit is an opt-in backwards compatible soft fork that preserves the trustless, decentralized model, it should be activated.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Bitcoin the Freedom Fighter]]></title>
    <link href="http://mattcampbell.nyc/2017/02/17/bitcoin-the-freedom-fighter/"/>
    <updated>2017-02-17T21:36:41-05:00</updated>
    <id>http://mattcampbell.nyc/2017/02/17/bitcoin-the-freedom-fighter</id>
    <content type="html"><![CDATA[<p>Bitcoin represents a mental stepping stone, a philosophical spring board from which I&rsquo;m better able to envision a future not controlled by the State and its numerous appendages (the FBI, CIA) and countless subsidiaries. By breaking the link between money and sovereignty (there are neither Presidents nor sovereigns printed on bitcoins), Bitcoin paves the way for a tidal wave of cultural, social, and technological innovation and progress. Since Bitcoin offers an Internet of Money with no inherent overlap with existing (i.e. fiat) monetary and financial systems, over time as adoption rises, people will be motivated to keep an ever-increasing proportion of their value in Bitcoins <strong>because it is better money.</strong> This last point is not debatable; it is not an opinion, it is not fake news, it is fact. Fiat money is not yours (aside from cash; but what portion of your value do you hold in cash?) - it is merely an IOU, a ledger balance. When you log into your online banking (assuming you live in one of the advanced economies where we have access to such financial services), the money that you see and claim to &ldquo;have in your account&rdquo; has in reality been lent out or applied to some probably more risky strategy like trading or financing of some exotic, complicated deal loaded with tantalizing fees for the bankers involved. If - or rather, when, given the history of financial crises, which seem to be part of the human economic condition - there is a run on the bank and the FDIC, you will be forced to get in line with all the rest (and probably take a massive haircut, i.e you will lose most or all of the money held in bank accounts).</p>

<p>This is simply not the case with Bitcoin. You <strong><em>are</em></strong> your bank. Bitcoin is strictly a bearer asset, where possession of the private key that allows your coins to be spent is ten-tenths of the law, so to speak.</p>

<blockquote><p>But, bitcoins are not very useful today. I have to wait at least 20 minutes for my transactions to be confirmed; transaction fees are too high, I pay nothing to use my credit cards. Why would <em>anyone ever use Bitcoin</em>?</p></blockquote>

<p>Ask the people in Africa, South America, East Asia, and so on, where each morning you wake up and hope that your grab bag of problems created by Big Brother doesn&rsquo;t have a surprise waiting for you. That list includes things like profound corruption &amp; graft, the social strangehold wraught by nepotism at all levels of socieyt, hyperinflation of your currency that destroys your purchasing power on a daily basis, oppressive political regimes which rob &amp; pillage the people, and so on.</p>

<p>If, 10 years ago before Bitcoin was invented, someone has asked you the following question, how would you have responded?</p>

<blockquote><p>How long would it take to design an Internet of Money which is not controlled by any central arbiter, no government, no corporation; a freely accessible network that cuts out the banks and turns the global financial-monetary system on its head and renders it utterly useless?</p></blockquote>

<p>I suspect you&rsquo;d either laugh, stare, or walk away, thinking something like, &ldquo;Dreamers, who needs &lsquo;em.&rdquo; We all would have. Bitcoin has existed for 8 short years and it&rsquo;s already significantly better than SWIFT, ACH, and most bank transfer services around the world.</p>

<p>In 10 years, maybe 5, all the &ldquo;problems&rdquo; that exist today with Bitcoin will be solved. Lightning Network is coming, SegWit will be adopted, and the impact of Bitcoin&rsquo;s open, permissionsless protocol allowing for <a href="https://www.youtube.com/watch?v=n2yD1PSWBU0">exponential innovation</a> will render all the world&rsquo;s fiat currencies laughably, hopelessly obsolete with no shot of ever catching up. From there, the virtuous cycle of utility begetting adoption <em>ad infinitum</em> will kick in, and then it&rsquo;s simply game over for the incumbents.</p>

<p>So, what happens to things like taxes when, in the future, everyone is storing their value in Bitcoin, where it <a href="http://www.libertylifetrail.com/2016/04/04/the-top-use-cases-for-bitcoin/">is easy to hide it from the prying eyes of the State and even your spouse</a>? It will trigger a forced revolution, a painful, messy, chaotic breaking with the past - a cultural &amp; social forest fire which will wipe out the old guard and the incumbents, anyone standing in the way of progress, and will give the future over to the nerds and to the Individual. Power structures like governments will no longer be able to domineer over their &ldquo;subjects&rdquo; by dictating and controlling what they can (buy things at Wal-Mart, please!) and cannot (that politician is evil, and since you donated to her you must be, too!) do with your money. The State and any centralized entity will only be able to grow as large as the exact number of Individuals which explicitly &ldquo;vote&rdquo; to support that structure, where voting is represented as financial support - buying a product from a company, paying for a service, donations, or even paying taxes if you&rsquo;d like.</p>

<p>The future is bright for the Individual, but the transition will be difficult. And we really haven&rsquo;t even begun yet. Remember: <a href="http://www.kurzweilai.net/the-law-of-accelerating-returns">all exponential relationships appear to be linear at the beginning</a>. I hope I live long enough to see the revolution in full swing.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Bitcoin and Taxes (Your Favorite Topic!)]]></title>
    <link href="http://mattcampbell.nyc/2016/11/25/bitcoin-and-taxes/"/>
    <updated>2016-11-25T12:18:58-05:00</updated>
    <id>http://mattcampbell.nyc/2016/11/25/bitcoin-and-taxes</id>
    <content type="html"><![CDATA[<blockquote><p>&ldquo;Each $5,000 of annual tax payments made over a 40-year period reduces your net worth by $2.2 million assuming a 10% annual return on your investments,&rdquo; reports James Dale Davidson in <a href="https://www.amazon.com/The-Sovereign-Individual-Transition-Information/dp/0684832720"><em>The Sovereign Individual: Mastering the Transition to the Information Age</em></a></p></blockquote>

<p>Just let that sink in for a bit please. Mull over the figures in your delicate psyche. Imagine the impact of &#36;2.2mm on your future.</p>

<p>&hellip; now, who&rsquo;s ready to talk about taxes?!</p>

<h3>Is Bitcoin useful for tax evasion?</h3>

<p><small>(<strong>NOTE</strong>: This is not tax advice, nor am I suggesting you seek to evade paying taxes. This post is for entertainment purposes only.)</small></p>

<p>There are two types of taxation regimes the world over: You either live in a country with <strong>competent</strong> or <strong>incompetent</strong> tax authorities.</p>

<p>If incompetent, there are a dozen other ways to avoid paying taxes, probably all of them easier than Bitcoin.</p>

<p>The United States is certainly one of the more competent tax collectors in the world via its &lsquo;revenue&rsquo; (talk about a euphemism) arm, the IRS.</p>

<p>So our question is really: is it possible to use bitcoin for tax evasion within the US?</p>

<h3>What can the IRS <em>do</em>, exactly?</h3>

<p>As of today, the IRS simply <a href="https://bitcoinmagazine.com/articles/tax-day-is-coming-a-primer-on-bitcoin-and-taxes-1459786613">hopes that you report any capital gains on profits obtained on net BTC purchases</a>. However, it&rsquo;s clear the IRS is trying to move from &lsquo;hope&rsquo; to &lsquo;coerce&rsquo; as its policy verb of choice: they&rsquo;ve <a href="http://www.coindesk.com/irs-seeking-data-coinbases-bitcoin-customers/">just asked for a broad and sweeping disclosure from Coinbase</a> regarding its customers&#8217; historical transaction data. Should this data be handed over to the Feds, you can bet they will start building a ledger for each customer - purchases made (volume and price) net of sales (again, volume and price) and send you a capital gains bill for any PNL realized on those transactions.</p>

<p>However, this doesn&rsquo;t address situations in which you&rsquo;ve used Coinbase (or another exchange like <a href="https://gemini.com/">Gemini</a>) solely to purchase your coins, and immediately withdrawn them to your personal, private wallet.</p>

<p>What will the IRS&#8217; policy be regarding these murky situations? Remember, I&rsquo;m saying &lsquo;murky&rsquo; here because <strong>they do not know the fate of your withdrawn bitcoins</strong>. That means that you could have:</p>

<ul>
<li>lost your coins -> you&rsquo;d claim a capital <strong>loss</strong> in this case, since the capital you outlaid upfront is now worth exactly $0</li>
<li>held onto your coins -> you&rsquo;d report nothing as you only incur capital gains upon <em>sale</em> of your investment</li>
<li>sold your coins -> you&rsquo;re supposed to report this honestly and pay capital gains</li>
</ul>


<p>As you can see, the main issue here for the IRS is their <strong>total and utter lack of transparency</strong>. Bitcoin does not need the IRS&#8217; nor the Federal government&rsquo;s blessing to exist - it just does. It is a completely separate, autonomous payment network that is under the control of no single individual or entity. There is no one rubber-stamping transactions like the Federal Reserve does in this country.</p>

<p>Some open questions, however, remain regarding the extent to which the IRS could pursue an individual (i.e. audit them) if they suspect misreporting of capital gains/losses regarding cryptocurrency holdings. Will they conduct rigorous <a href="http://www.coindesk.com/what-block-chain-analysis-tells-bitcoin/">blockchain analysis</a> - which is extremely computationally expensive (by design, in a way&hellip; more on this in another post perhaps) - to try and piece together a story and send you a tax bill? This strategy is feasible in theory, but would represent a huge consumption of their resources in practice.</p>

<p>The fact is that the tools at the disposal of the IRS are limited at best.</p>

<p>Perhaps, though, this is for the better.</p>

<h2>A better tax regime</h2>

<p>In bitcoin, you pay taxes on every transaction - it&rsquo;s called the transaction fee. You can <em>voluntarily</em> pay a higher fee and you will increase the likelihood that your (probably time-sensitive) transaction will be part of the network&rsquo;s next block, i.e. your transaction will be settled in a much more timely manner. This is an example of a <a href="https://en.wikipedia.org/wiki/Voluntary_taxation">voluntary tax system</a> (credit to <a href="https://twitter.com/TravisPatron">@TravisPatron</a> for <a href="http://www.coindesk.com/why-bitcoin-creates-a-voluntary-tax-system/">exposing me to this concept</a>).</p>

<blockquote><p>[The Bitcoin] transactions queue represents a voluntary, pay-for-performance taxation structure where the performance derived from the system is dependent upon how much taxation [a user is willing to] pay.</p></blockquote>

<p>Bitcoin puts the power back in the hands of its users. If you value the service, the right to use the Bitcoin network to move value between two nodes in the network, then you pay tax for that performance.</p>

<p>Imagine a system where you pay tax for roads only when you use the roads to drive. Or you only pay taxes to schools in the form of some tuition cost when your children are attending those schools.</p>

<p>I think that a tax regime that aligns a person&rsquo;s tax liabilities with his or her <em>behaviors</em>  (where a behavior is an expression of their preference) is a compelling vision for the future. Perhaps you will agree.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[WorldWideWebCoin: A Thought Experiment]]></title>
    <link href="http://mattcampbell.nyc/2016/10/26/world-wide-web-coin-a-thought-experiment/"/>
    <updated>2016-10-26T14:18:58-04:00</updated>
    <id>http://mattcampbell.nyc/2016/10/26/world-wide-web-coin-a-thought-experiment</id>
    <content type="html"><![CDATA[<p><sub>
<em>WorldWideWebCoin - WWWCoin vs. Bitcoin - More usefulness leads to more adoption leads to more usefulness</em>
</sub></p>

<p>Bitcoin is <a href="https://www.coinbase.com/what-is-bitcoin?locale=en">many things</a> - open source peer-to-peer (p2p) digital money; an <a href="http://fortune.com/2016/10/18/winklevoss-state-street-bitcoin-etf-administrator/">alternative asset class for investors</a>; and possibly the global reserve currency of the future, when <a href="https://startupboy.com/2014/04/01/the-fifth-protocol/">machines are participating in marketplaces autonomously without human intervention</a>.</p>

<p>The value of one Bitcoin (1 BTC) in essence is a reflection of its <strong>usefulness</strong> across the many functions in which it&rsquo;s being used.</p>

<p>Bitcoin starts to look more like a safe haven asset that&rsquo;s decorrelated with, say, the S&amp;P500? Its value should increase.</p>

<p>Bitcoin can be used more and more places to buy goods and services? Its value should increase.</p>

<p>More companies offer employees compensation partially of wholly in Bitcoin? Its value should increase.</p>

<h2>WWWCoin Hypothetical Price History</h2>

<p>Let&rsquo;s say there had been a <strong>WWWCoin</strong> back in 1994 shortly after Tim Burners-Lee <a href="https://en.wikipedia.org/wiki/World_Wide_Web">invented the World Wide Web</a> in the late 1980s.</p>

<p>Now picture a chart of that coin&rsquo;s valuation from its inception in c. 1989; through the <a href="https://en.wikipedia.org/wiki/Dot-com_bubble">dot-com bubble&rsquo;s bursting</a> beginning in 2000; and finally bring it through to the present. What would that chart look like? Here&rsquo;s my take&hellip;</p>

<div style="text-align:center">
<img src="https://www.dropbox.com/s/k30yfttch1o54yl/Screenshot%202016-10-26%2016.24.53.png?dl=1"/>
</div>


<h2>Bitcoin Realized Price History</h2>

<p>Just for fun, let&rsquo;s see how our hypothetical WWWCoin chart compares to the realized BTC price chart to date.</p>

<div style="text-align:center">
<img src="https://www.dropbox.com/s/d5ukaisoi2f194n/Screenshot%202016-10-26%2015.29.20.png?dl=1"/>
</div>


<p>Some similarities of note:</p>

<ul>
<li>Early precipitous rise leads to a bubble, i.e. overdone price increase relative to the <strong>actual + potential usefulness of both the internet and Bitcoin</strong></li>
<li>Steady, grinding recovery following the first major crash in price as <strong>the technology continues to make strides in terms of usefulness and applicability</strong></li>
<li><strong>No clear upper bound on price as usefulness enters into a virtuous feedback loop</strong> - more adoption means more usefulness means more adoption, ad nauseam.</li>
</ul>


<p>The last point has only been realized to date in the case of the Internet; my prediction is Bitcoin will follow a similar pattern. Have you heard of <a href="https://en.wikipedia.org/wiki/Micropayment">micropayments</a>? The technology that will finally <a href="https://medium.com/on-blendle/in-a-world-of-ad-blockers-we-need-micropayments-9ddb2f6793cf#.cn7bn57v8">kill YouTube ads</a>? Well, they&rsquo;re almost here, courtesy of Bitcoin and the <a href="https://lightning.network/">Lightning Network</a>.</p>

<p>I think we&rsquo;re standing on the precipice of an inflection point in Bitcoin&rsquo;s history - at which the feedback between Bitcoin&rsquo;s expanding utility and increasing price becomes obvious to just about everyone. Do you want to participate or not?</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Private Methods Can Save Some TDD Headache]]></title>
    <link href="http://mattcampbell.nyc/2016/02/17/private-methods-can-save-some-tdd-headache/"/>
    <updated>2016-02-17T16:18:58-05:00</updated>
    <id>http://mattcampbell.nyc/2016/02/17/private-methods-can-save-some-tdd-headache</id>
    <content type="html"><![CDATA[<p>Let&rsquo;s face it: TDD is hard. I would argue that there&rsquo;s value in that difficulty - TDD forces you to address domain modeling decisions early on; to declare your API before implementing it. I have spent more time than I care to admit staring at some <code>*_spec.rb</code> file, unsure about how to translate the loosely-defined conception of behavior in my brain into test examples.</p>

<p>However, there&rsquo;s good <a href="news:">news:</a> relying on private methods can some (some) of this pain.</p>

<h2>A Rails Example</h2>

<p>Let&rsquo;s say your co-worker has asked you to write a webhooks microservice. This standalone API will be responsible for:</p>

<ol>
<li>Creating new callback subscriptions for users that want to subscribe</li>
<li>Sending the callback payloads to said user&rsquo;s callback(s) URL(s)</li>
</ol>


<blockquote><p>&lsquo;A crucial part of any callbacks API is delivering, over the web via HTTP POST, the actual callback payload,&rsquo; you reason aloud.</p></blockquote>

<p>To that end, you conjure up a vision of some <code>DeliverCallbackJob</code> class that needs only a <code>User</code> instance and the callback payload (probably a long string of JSON, like a serialized web response). Following a common pattern, you decide the interface for this class will be limited to one method:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="no">DeliverCallbackJob</span><span class="c1">#perform!</span>
</span></code></pre></td></tr></table></div></figure>


<p>In adherence to TDD, we may start with an example (RSpec DSL here) that looks like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="no">RSpec</span><span class="o">.</span><span class="n">describe</span> <span class="no">DeliverCallbackJob</span> <span class="k">do</span>
</span><span class='line'>  <span class="c1"># NOTE: some/much setup code omitted...</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">let</span><span class="p">(</span><span class="ss">:deliverer</span><span class="p">)</span> <span class="p">{</span> <span class="no">DeliverCallbackJob</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">user</span><span class="p">,</span> <span class="n">payload</span><span class="p">)</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">describe</span> <span class="s2">&quot;#perform!&quot;</span> <span class="k">do</span>
</span><span class='line'>    <span class="n">subject</span> <span class="p">{</span> <span class="n">deliverer</span><span class="o">.</span><span class="n">perform!</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">it</span> <span class="s2">&quot;sends a callback to all of the user&#39;s associated Callback#callback_url endpoints&quot;</span> <span class="k">do</span>
</span><span class='line'>      <span class="n">expect</span><span class="p">(</span><span class="no">Net</span><span class="o">::</span><span class="no">HTTP</span><span class="p">)</span><span class="o">.</span><span class="n">to</span> <span class="n">receive</span><span class="p">(</span><span class="ss">:post</span><span class="p">)</span><span class="o">.</span><span class="n">exactly</span><span class="p">(</span><span class="n">user</span><span class="o">.</span><span class="n">callbacks</span><span class="o">.</span><span class="n">size</span><span class="p">)</span><span class="o">.</span><span class="n">times</span>
</span><span class='line'>      <span class="n">subject</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now, <code>User#callbacks</code> is a standard <code>ActiveRecord::Associations::ClassMethods#has_many</code> association. So we may be tempted to now drop into our class definition and start implementing:</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='ruby'><span class='line'><span class="c1">#NOTE: This is pseudo code! Read between the lines somewhat please :)</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">DeliverCallbackJob</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">perform!</span>
</span><span class='line'>    <span class="n">user</span><span class="o">.</span><span class="n">callbacks</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">callback</span><span class="o">|</span>
</span><span class='line'>      <span class="no">Net</span><span class="o">::</span><span class="no">HTTP</span><span class="o">.</span><span class="n">post</span><span class="p">(</span><span class="n">callback</span><span class="o">.</span><span class="n">callback_url</span><span class="p">)</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<h2>The Problem</h2>

<p>This works, yes - but we&rsquo;ve unwittingly coupled logic unrelated to delivering a callback to this class. Specifically (and this can be hard to see in Rails a lot of the times), the usage of <code>user.callbacks</code> is the point of coupling. <code>DeliverCallbackJob</code> does not and should not care how we get a (possibly empty) list of callbacks from our <code>user</code> record.</p>

<h2>Re-writing our Test</h2>

<p>A better test example - one that would have exposed this tendency to couple to the ActiveRecord API - might read 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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">describe</span> <span class="s2">&quot;#perform!&quot;</span> <span class="k">do</span>
</span><span class='line'>  <span class="n">subject</span> <span class="p">{</span> <span class="n">deliverer</span><span class="o">.</span><span class="n">perform!</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">let</span><span class="p">(</span><span class="ss">:size</span><span class="p">)</span>      <span class="p">{</span> <span class="mi">4</span> <span class="p">}</span>
</span><span class='line'>  <span class="n">let</span><span class="p">(</span><span class="ss">:callback</span><span class="p">)</span>  <span class="p">{</span> <span class="n">double</span><span class="p">(</span><span class="ss">callback_url</span><span class="p">:</span> <span class="s2">&quot;foo.bar.com/callback&quot;</span><span class="p">)</span> <span class="p">}</span>
</span><span class='line'>  <span class="n">let</span><span class="p">(</span><span class="ss">:callbacks</span><span class="p">)</span> <span class="p">{</span> <span class="nb">Array</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">size</span><span class="p">,</span> <span class="n">callback</span><span class="p">)</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">before</span> <span class="p">{</span> <span class="n">expect</span><span class="p">(</span><span class="n">deliverer</span><span class="p">)</span><span class="o">.</span><span class="n">to</span> <span class="n">receive</span><span class="p">(</span><span class="ss">:callbacks</span><span class="p">)</span><span class="o">.</span><span class="n">and_return</span><span class="p">(</span><span class="n">callbacks</span><span class="p">)</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">it</span> <span class="s2">&quot;sends a callback to all of the user&#39;s associated Callback#callback_url endpoints&quot;</span> <span class="k">do</span>
</span><span class='line'>    <span class="n">expect</span><span class="p">(</span><span class="no">Net</span><span class="o">::</span><span class="no">HTTP</span><span class="p">)</span><span class="o">.</span><span class="n">to</span> <span class="n">receive</span><span class="p">(</span><span class="ss">:post</span><span class="p">)</span><span class="o">.</span><span class="n">with</span><span class="p">(</span><span class="s2">&quot;foo.bar.com/callback&quot;</span><span class="p">)</span><span class="o">.</span><span class="n">exactly</span><span class="p">(</span><span class="n">size</span><span class="p">)</span><span class="o">.</span><span class="n">times</span>
</span><span class='line'>    <span class="n">subject</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>The key difference here is the assertion we&rsquo;ve added to the <code>before</code> hook:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">before</span> <span class="p">{</span> <span class="n">expect</span><span class="p">(</span><span class="n">deliverer</span><span class="p">)</span><span class="o">.</span><span class="n">to</span> <span class="n">receive</span><span class="p">(</span><span class="ss">:callbacks</span><span class="p">)</span><span class="o">.</span><span class="n">and_return</span><span class="p">(</span><span class="n">callbacks</span><span class="p">)</span> <span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>We&rsquo;ve implicitly augmented the interface of <code>DeliverCallbackJob</code> by a method <code>#callbacks</code>.</p>

<p>This is a really good thing! Now, we have a place to put the logic of &ldquo;gather all the <code>Callback</code> records against which I need to deliver the callback payload at hand&rdquo;. And as such, we have a new point at which we can introduce stubs or mocks in our tests.</p>

<p>In order to get this spec passing, we might refactor our class like so:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<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='ruby'><span class='line'><span class="k">class</span> <span class="nc">DeliverCallbackJob</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">perform!</span>
</span><span class='line'>    <span class="n">callbacks</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">callback</span><span class="o">|</span>
</span><span class='line'>      <span class="no">Net</span><span class="o">::</span><span class="no">HTTP</span><span class="o">.</span><span class="n">post</span><span class="p">(</span><span class="n">callback</span><span class="o">.</span><span class="n">callback_url</span><span class="p">)</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="kp">private</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">callbacks</span>
</span><span class='line'>    <span class="c1"># This is now an implementation detail, as opposed to a closely coupled</span>
</span><span class='line'>    <span class="c1"># and hidden dependency stowed away within the `perform!` method.</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1"># For now, we&#39;re using ActiveRecord so implementation may be unchaged</span>
</span><span class='line'>    <span class="c1"># relative to our first version of this class... but if we drop Rails/AR</span>
</span><span class='line'>    <span class="c1"># in the future, we have a clearly documented spot to change this logic.</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">user</span><span class="o">.</span><span class="n">callbacks</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Recap</h2>

<p>So what did we learn today? When you&rsquo;re struggling to get through your TDD, it tends to indicate hidden coupling and dependencies. When you feel this happening, take a closer look at your implementation and see what can be moved into private methods. Then, in your test examples, make those dependencies explicit so that you can mock, stub, or whatever suits you.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Extend an Instance to Dynamically Include]]></title>
    <link href="http://mattcampbell.nyc/2015/12/05/extending-an-instance-to-dynamically-include/"/>
    <updated>2015-12-05T13:52:30-05:00</updated>
    <id>http://mattcampbell.nyc/2015/12/05/extending-an-instance-to-dynamically-include</id>
    <content type="html"><![CDATA[<p>Here&rsquo;s a question for you lovely developers (and non-developers, too!) out there: how can we <strong>dynamically</strong> include behavior from a specific module at runtime? Put differently, is it possible to include one specific module&rsquo;s behavior <strong>after</strong> a <code>class</code> definition has already been read in? The typical Ruby include-behavior-from-a-module pattern looks something like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Employee</span>
</span><span class='line'>  <span class="kp">attr_accessor</span> <span class="ss">:can_be_promoted_to_manager</span>
</span><span class='line'>
</span><span class='line'>  <span class="kp">include</span> <span class="no">Trainable</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">.</span><span class="n">.</span><span class="o">.</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>&hellip; where <code>Trainable</code> might extend the behavior of <code>Employee</code> instances something like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">module</span> <span class="nn">Trainable</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">train!</span>
</span><span class='line'>    <span class="c1">## some training-related code here...</span>
</span><span class='line'>    <span class="nb">self</span><span class="o">.</span><span class="n">can_be_promoted_to_manager</span> <span class="o">=</span> <span class="kp">true</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>This is a contrived example, clearly, but the pattern should look familiar: in Ruby, we love to <a href="https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)">encapsulate behavior</a> into modules and <code>include</code> them - the name for this practice is <a href="https://en.wikipedia.org/wiki/Separation_of_concerns">separation of concerns</a>. However, since we write the <code>include</code> directive within a class-level <a href="https://newcircle.com/bookshelf/ruby_tutorial/scope">scope</a>, we cannot for example use an instance of <code>Employee</code> itself to determine which module&rsquo;s behavior we&rsquo;d like to include. Let me explain with a quick example&hellip;</p>

<h3>Different Modules for Different Training</h3>

<p>Assume that instead of one <code>Trainable</code> module, we really have multiple modules that encapsulate distinct forms of employee training like 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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">module</span> <span class="nn">ManagerTrainable</span> <span class="p">;</span> <span class="k">end</span>
</span><span class='line'><span class="k">module</span> <span class="nn">TechnicianTrainable</span> <span class="p">;</span> <span class="k">end</span>
</span><span class='line'><span class="k">module</span> <span class="nn">ExecutiveTrainable</span> <span class="p">;</span> <span class="k">end</span>
</span><span class='line'><span class="k">module</span> <span class="nn">SalesPersonTrainable</span> <span class="p">;</span> <span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>(NB: As you can see, I&rsquo;ve omitted any actual methods from these modules above, but use your imagination! e.g. <code>ExecutiveTrainable#soul_suck!</code>, or maybe <code>SalesPersonTrainable#learn_to_peddle!</code>)</p>

<p>These modules may have also been written to reflect the various real-world types of <code>Employee</code> that are modeled in our Ruby application:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">manager</span>    <span class="o">=</span> <span class="no">Employee</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">type</span><span class="p">:</span> <span class="ss">:manager</span><span class="p">)</span>
</span><span class='line'><span class="n">technician</span> <span class="o">=</span> <span class="no">Employee</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">type</span><span class="p">:</span> <span class="ss">:employee</span><span class="p">)</span>
</span></code></pre></td></tr></table></div></figure>


<p>Each of these <code>employee</code>s also need to be able to go through some form of &ldquo;training&rdquo;. So, in order to ensure that all of <code>Employee</code> types can be <code>train!</code>&lsquo;ed in the appropriate manner, we can simply <code>include</code> all modules at the class level:</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='ruby'><span class='line'><span class="k">class</span> <span class="nc">Employee</span>
</span><span class='line'>  <span class="kp">include</span> <span class="no">ManagerTrainable</span>
</span><span class='line'>  <span class="kp">include</span> <span class="no">TechnicianTrainable</span>
</span><span class='line'>  <span class="kp">include</span> <span class="no">ExecutiveTrainable</span>
</span><span class='line'>  <span class="kp">include</span> <span class="no">SalesPersonTrainable</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">.</span><span class="n">.</span><span class="o">.</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Unforutnately, this has a nubmer of problems. First, it doesn&rsquo;t communicate the <a href="https://signalvnoise.com/posts/3531-intention-revealing-methods">developer&rsquo;s intent</a> very clearly. Someone coming along and reading this code in some months&#8217; time might ask, &ldquo;What&rsquo;s going on - why all these variations of <code>Trainable</code>?&rdquo; Second, we risk <a href="http://ruby-journal.com/how-to-open-slash-override-slash-monkey-patch-a-class-in-ruby/">overwriting methods</a> if the modules share the same/similar interfaces (for example, if each module implements <code>#train!</code> independently, you would have to change the method names, or apply logic to the ordering of our 4 <code>include</code> directives, or&hellip; well, you&rsquo;d have a real problem on your hands to solve at that point).</p>

<h2><code>extend</code> at instance-level scope to simulate <code>include</code> instead.</h2>

<p>Ruby thankfully offers a very elegant, dynamic solution to this problem. Since the logic of which <code>Trainable</code> module should be included is a function of the instance&rsquo;s <code>employee.type</code>, we can use a lifecycle hook in combination with <code>extend</code> like so:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<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='ruby'><span class='line'><span class="k">class</span> <span class="nc">Employee</span>
</span><span class='line'>  <span class="kp">attr_accessor</span> <span class="ss">:type</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">opts</span> <span class="o">=</span> <span class="p">{})</span>
</span><span class='line'>    <span class="c1"># first set the object&#39;s attributes as usual</span>
</span><span class='line'>    <span class="k">super</span>
</span><span class='line'>    <span class="c1"># extend the appropriate module&#39;s behavior to the instance&#39;s Eigenclass (more on this shortly)</span>
</span><span class='line'>    <span class="kp">extend</span><span class="p">(</span><span class="no">Kernel</span><span class="o">.</span><span class="n">const_get</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="nb">self</span><span class="o">.</span><span class="n">type</span><span class="si">}</span><span class="s2">Trainable&quot;</span><span class="p">))</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>In <a href="">Rails</a>, you could refactor this by using the provided <a href="">object lifecycle hooks</a>, e.g. <a href=""><code>after_initialize</code></a> like so:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Employee</span>
</span><span class='line'>  <span class="n">after_initialize</span> <span class="ss">:extend_trainable_behavior</span>
</span><span class='line'>
</span><span class='line'>  <span class="o">.</span><span class="n">.</span><span class="o">.</span>
</span><span class='line'>
</span><span class='line'>  <span class="kp">private</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">extend_trainable_behavior</span>
</span><span class='line'>    <span class="c1"># So, for an `employee` whose type is &#39;manager&#39;, we are effectively including `ManagerTrainable`&#39;s behavior only!</span>
</span><span class='line'>    <span class="kp">extend</span><span class="p">(</span><span class="no">Kernel</span><span class="o">.</span><span class="n">const_get</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="nb">self</span><span class="o">.</span><span class="n">type</span><span class="si">}</span><span class="s2">Trainable&quot;</span><span class="p">))</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Code Example: add <code>Human#moniker</code> behavior with both class-level <code>include</code> and instance-level <code>extend</code></h2>

<p>In the following code example (where all humans are named <code>"Matt!"</code>, ha), you can see how either <code>include</code> or <code>extend</code> can be used (at different scopes, of course) to tell all <code>Human</code>s how to report their <code>name</code>. Note that console/IO output is indicated by commented out lines with a single <code>#</code> - you&rsquo;d get the same output by copy-pasting
this code into a live REPL.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="c1">## Here&#39;s our nameable concern. We use both of Ruby&#39;s provided hooks - included and extended - to report</span>
</span><span class='line'><span class="c1">## when either event takes place at runtime. </span>
</span><span class='line'>
</span><span class='line'><span class="k">module</span> <span class="nn">Nameable</span>
</span><span class='line'>  <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">included</span><span class="p">(</span><span class="n">base</span><span class="p">)</span>
</span><span class='line'>    <span class="nb">puts</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="nb">self</span><span class="si">}</span><span class="s2"> included in </span><span class="si">#{</span><span class="n">base</span><span class="si">}</span><span class="s2">.&quot;</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">extended</span><span class="p">(</span><span class="n">base</span><span class="p">)</span>
</span><span class='line'>    <span class="nb">puts</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="nb">self</span><span class="si">}</span><span class="s2"> extended in </span><span class="si">#{</span><span class="n">base</span><span class="si">}</span><span class="s2">.&quot;</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">moniker</span>
</span><span class='line'>    <span class="s2">&quot;Matt!&quot;</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">HumanWithNormalInclude</span>
</span><span class='line'>  <span class="kp">include</span> <span class="no">Nameable</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'><span class="c1"># Nameable included in HumanWithNormalInclude</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">HumanWithInstanceExtend</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span>
</span><span class='line'>    <span class="k">super</span>
</span><span class='line'>    <span class="n">extend_behavior</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">extend_behavior</span>
</span><span class='line'>    <span class="kp">extend</span> <span class="no">Nameable</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="n">included_human</span> <span class="o">=</span> <span class="no">HumanWithNormalInclude</span><span class="o">.</span><span class="n">new</span>
</span><span class='line'><span class="n">included_human</span><span class="o">.</span><span class="n">moniker</span>
</span><span class='line'><span class="c1"># &quot;Matt!&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="n">extended_human</span> <span class="o">=</span> <span class="no">HumanWithInstanceExtend</span><span class="o">.</span><span class="n">new</span>
</span><span class='line'><span class="c1"># Nameable extended in #&lt;HumanWithInstanceExtend:0x007fa939a0da40&gt;.</span>
</span><span class='line'><span class="c1"># &lt;HumanWithInstanceExtend:0x007fa939a0da40&gt;</span>
</span><span class='line'><span class="n">extended_human</span><span class="o">.</span><span class="n">moniker</span>
</span><span class='line'><span class="c1"># &quot;Matt!&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Black magic?! How does it work?!!</h2>

<p>To understand why <code>extend</code>ing at an instance scope works the way it does, it will help to understand the concept of <a href="http://madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html">&ldquo;eigenclasses&rdquo;</a> in Ruby. First, let&rsquo;s define eigenclass and then write a sort of helper method that tells us any object&rsquo;s eigenclass on demand.</p>

<blockquote><p><strong>Eigenclass</strong>: a dynamically created anonymous class that Ruby inserts into the method lookup path <em>any time at least one singleton method is added to an object</em>. (I added the last bit in italics&hellip; I think it&rsquo;s right, ha.)</p></blockquote>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Object</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">eigenclass</span>
</span><span class='line'>    <span class="k">class</span> <span class="o">&lt;&lt;</span> <span class="nb">self</span>  <span class="c1"># this opens us to the scope of the receiver&#39;s eigenclass</span>
</span><span class='line'>      <span class="nb">self</span>         <span class="c1"># return the eigenclass itself</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>To tie the eigenclass concept back into our previous code example, let&rsquo;s try to answer the question: <strong>Where does <code>extended_human.moniker</code> actually &ldquo;live&rdquo;?</strong></p>

<p>If we query both of our instances&#8217; classes, it&rsquo;s not immediately clear where our <code>extended_human</code> instance&rsquo;s <code>#moniker</code> method lives&hellip;</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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="o">[</span><span class="mi">26</span><span class="o">]</span> <span class="n">pry</span><span class="p">(</span><span class="n">main</span><span class="p">)</span><span class="o">&gt;</span> <span class="n">included_human</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">ancestors</span>
</span><span class='line'><span class="o">[</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">0</span><span class="o">]</span> <span class="no">HumanWithNormalInclude</span> <span class="o">&lt;</span> <span class="no">Object</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">1</span><span class="o">]</span> <span class="no">Nameable</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">2</span><span class="o">]</span> <span class="no">Object</span> <span class="o">&lt;</span> <span class="no">BasicObject</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">3</span><span class="o">]</span> <span class="no">PP</span><span class="o">::</span><span class="no">ObjectMixin</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">4</span><span class="o">]</span> <span class="no">Kernel</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">5</span><span class="o">]</span> <span class="no">BasicObject</span>
</span><span class='line'><span class="o">]</span>
</span><span class='line'><span class="o">[</span><span class="mi">27</span><span class="o">]</span> <span class="n">pry</span><span class="p">(</span><span class="n">main</span><span class="p">)</span><span class="o">&gt;</span> <span class="n">extended_human</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">ancestors</span>
</span><span class='line'><span class="o">[</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">0</span><span class="o">]</span> <span class="no">HumanWithInstanceExtend</span> <span class="o">&lt;</span> <span class="no">Object</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">1</span><span class="o">]</span> <span class="no">Object</span> <span class="o">&lt;</span> <span class="no">BasicObject</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">2</span><span class="o">]</span> <span class="no">PP</span><span class="o">::</span><span class="no">ObjectMixin</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">3</span><span class="o">]</span> <span class="no">Kernel</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">4</span><span class="o">]</span> <span class="no">BasicObject</span>
</span><span class='line'><span class="o">]</span>
</span></code></pre></td></tr></table></div></figure>


<p>I typically query an object&rsquo;s class&rsquo;s ancestors when I want to see its inheritance hierarchy (where &lsquo;inheritance&rsquo; is a combination of mixins and classical inheritance, i.e. <code>class Foo &lt; Bar</code>) as part of finding where a particular method might have come from. This exercise reminds us that in Ruby, the <code>Kernel</code> module (responsible for <code>eval</code>, <code>gets</code>, <code>puts</code>, etc.) is quite high up in the object hierarchy, and as such its methods/behaviors are made available practically everywhere in a Ruby program.</p>

<blockquote><p><strong>Notably absent from <code>extended_human.class.ancestors</code>, however, is any reference to our <code>Nameable</code> mixin.</strong></p></blockquote>

<p>So - where is <code>extended_human.moniker</code> coming from then? Let&rsquo;s instead look through the instances&#8217; eigenclasses&#8217; ancestors:</p>

<h2>Ruby&rsquo;s method lookup path flows through eigenclasses first!</h2>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="o">[</span><span class="mi">29</span><span class="o">]</span> <span class="n">pry</span><span class="p">(</span><span class="n">main</span><span class="p">)</span><span class="o">&gt;</span> <span class="n">included_human</span><span class="o">.</span><span class="n">eigenclass</span><span class="o">.</span><span class="n">ancestors</span>
</span><span class='line'><span class="o">[</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">0</span><span class="o">]</span> <span class="no">HumanWithNormalInclude</span> <span class="o">&lt;</span> <span class="no">Object</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">1</span><span class="o">]</span> <span class="no">Nameable</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">2</span><span class="o">]</span> <span class="no">Object</span> <span class="o">&lt;</span> <span class="no">BasicObject</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">3</span><span class="o">]</span> <span class="no">PP</span><span class="o">::</span><span class="no">ObjectMixin</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">4</span><span class="o">]</span> <span class="no">Kernel</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">5</span><span class="o">]</span> <span class="no">BasicObject</span>
</span><span class='line'><span class="o">]</span>
</span><span class='line'><span class="o">[</span><span class="mi">30</span><span class="o">]</span> <span class="n">pry</span><span class="p">(</span><span class="n">main</span><span class="p">)</span><span class="o">&gt;</span> <span class="n">extended_human</span><span class="o">.</span><span class="n">eigenclass</span><span class="o">.</span><span class="n">ancestors</span>
</span><span class='line'><span class="o">[</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">0</span><span class="o">]</span> <span class="no">Nameable</span><span class="p">,</span>  <span class="c1"># Here it is!</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">1</span><span class="o">]</span> <span class="no">HumanWithInstanceExtend</span> <span class="o">&lt;</span> <span class="no">Object</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">2</span><span class="o">]</span> <span class="no">Object</span> <span class="o">&lt;</span> <span class="no">BasicObject</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">3</span><span class="o">]</span> <span class="no">PP</span><span class="o">::</span><span class="no">ObjectMixin</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">4</span><span class="o">]</span> <span class="no">Kernel</span><span class="p">,</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">5</span><span class="o">]</span> <span class="no">BasicObject</span>
</span><span class='line'><span class="o">]</span>
</span></code></pre></td></tr></table></div></figure>


<p>Aha - found it! Note that for our <code>extended_human</code>, <code>Nameable</code> is the very first ancestor in its <a href="https://blog.jcoglan.com/2013/05/08/how-ruby-method-dispatch-works/">method-lookup hierarchy</a>. This is because we <code>extend</code>&lsquo;ed <code>Nameable</code> directly into <code>extended_human</code>&rsquo;s eigenclass, as opposed to <code>include</code>&#8216;ing it in its containing class definition. And once again, to display this point 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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="o">[</span><span class="mi">31</span><span class="o">]</span> <span class="n">pry</span><span class="p">(</span><span class="n">main</span><span class="p">)</span><span class="o">&gt;</span> <span class="n">extended_human</span><span class="o">.</span><span class="n">eigenclass</span><span class="o">.</span><span class="n">ancestors</span> <span class="o">-</span> <span class="n">extended_human</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">ancestors</span>
</span><span class='line'><span class="o">[</span>
</span><span class='line'>  <span class="o">[</span><span class="mi">0</span><span class="o">]</span> <span class="no">Nameable</span>
</span><span class='line'><span class="o">]</span>
</span></code></pre></td></tr></table></div></figure>


<p>By making use of an anonymous class under the hood at runtime, Ruby gives us the ability to <strong>dynamically mixin behaviors at all levels of our programs - namely in our example, at both the class and instance level!</strong> Wo-man, I &lt;3 Ruby :)</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[How Fixed Gear Bicycling Taught Me About Dependency Injection]]></title>
    <link href="http://mattcampbell.nyc/2015/09/27/how-fixed-gear-bicycling-taught-me-about-dependency-injection/"/>
    <updated>2015-09-27T12:17:14-04:00</updated>
    <id>http://mattcampbell.nyc/2015/09/27/how-fixed-gear-bicycling-taught-me-about-dependency-injection</id>
    <content type="html"><![CDATA[<p>I became inspired to write this blog post after watching a great <a href="https://www.twitter.com/sandimetz">@sandimetz</a> <a href="https://www.youtube.com/watch?v=OMPfEXIlTVE">talk which she gave at RailsConf 2015</a>. Her subject was primarily the <a href="https://en.wikipedia.org/wiki/Null_Object_pattern">Null Object Pattern</a>, but she extends the fundamental principle - that objects, not conditionals nor excruciatingly tailored classes, should be used to encapsulate your system&rsquo;s behaviors - to the practical aspects of injecting dependencies required by your domain&rsquo;s fundamental objects. Let&rsquo;s take a look at what I mean by using a real-world example: my recently acquired (and already banged up - I&rsquo;ve had two flat tires already!) <a href="https://en.wikipedia.org/wiki/Fixed-gear_bicycle">fixed gear (a.k.a &ldquo;fixie&rdquo;) bike</a>. I want you to start asking yourself: if you were given the task of modeling in Ruby a fixed-gear bicycle alongside a &ldquo;normal&rdquo; or freewheel bicycle, what tools would you reach for - inheritance, composition, or otherwise?</p>

<h2>Modeling our <code>Bicycle</code></h2>

<p>Let&rsquo;s throw down a little code to start bringing our bicycle domain to life:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Bicycle</span>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:frame_size</span><span class="p">,</span> <span class="ss">:color</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">frame_size</span><span class="p">,</span> <span class="n">color</span><span class="p">)</span>
</span><span class='line'>    <span class="vi">@frame_size</span><span class="p">,</span> <span class="vi">@color</span> <span class="o">=</span> <span class="n">frame_size</span><span class="p">,</span> <span class="n">color</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">number_of_speeds</span>
</span><span class='line'>    <span class="n">freewheel</span> <span class="p">?</span> <span class="n">gear_count</span> <span class="p">:</span> <span class="mi">1</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">gear_count</span>
</span><span class='line'>    <span class="mi">1</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">freewheel</span>
</span><span class='line'>    <span class="kp">true</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Cool - now we can instantiate a new <code>Bicycle</code> with our frame size and color preferences. Moreover, we have a sensible default (at least for urban NYC bicycling) for our drivetrain set to single-speed and <a href="https://en.wikipedia.org/wiki/Freewheel">freewheel</a>. (Note that &lsquo;freewheel&rsquo; is distinct from fixed-gear. On a fixie, for example, it is not possible for the chain to disengage from the crank arms, i.e. the motion of the rider&rsquo;s pedals. On a freewheel bicycle, you can stop the motion of the pedals beneath you and the drivetrain will continue turning, allowing for what we call &lsquo;coasting&rsquo;.)</p>

<p>This is all well and good - until you find yourself moving to Brooklyn. In Brooklyn, fixed gear bikes are more popular, and it&rsquo;s probably got something to do with a hipster resurgence.</p>

<p>So now let&rsquo;s use our knowledge of OO and Ruby to model our fixed gear bicycle.</p>

<h2>Reach for inheritance first&hellip;?</h2>

<p>Here is a perfectly viable implementation of our fixie bicycle variant:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Fixie</span> <span class="o">&lt;</span> <span class="no">Bicycle</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">freewheel</span>
</span><span class='line'>    <span class="kp">false</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Easy! All we did was inherit from <code>Bicycle</code>, and modify the <code>#freewheel</code> method to instantiate a non-freewheel single-speed bicycle.</p>

<p>Now let&rsquo;s say, however, that your roommate would prefer a multi-speed bicycle. Once again using inheritance we may write some code like so:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">MultiGear</span> <span class="o">&lt;</span> <span class="no">Bicycle</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">gear_count</span>
</span><span class='line'>    <span class="vi">@gear_count</span> <span class="o">||=</span> <span class="mi">18</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>And once again, this has solved our problem. But, while effective, this solution raises a number of concerns. Mainly, we already have two distinct classes in order to account for two slight variations in <code>Bicycle</code> types. What do you imagine will happen to our system as the number of different variations grows? Put differently:</p>

<ul>
<li>Do we really need distinct, unique classes to model a single variation in the characteristics of our bicycle?</li>
<li>Does the organization of our code and the patterns therein easily communicate the distinctions we&rsquo;re attempting to convey?</li>
<li>Are we satisfied with the idea that, should our <code>Bicycle</code>s change in other aspects in the future, we&rsquo;ll continue to open new classes?</li>
</ul>


<h2>Where inheritance breaks down (pun intended)</h2>

<p>To focus on the last concern that we just raised, let&rsquo;s say you&rsquo;ve accepted a job as a delivery boy for a local Chinese restaurant. Most of those guys, since they&rsquo;re riding for hours a day, enhance their drivetrain with an electric motor which looks something like this:</p>

<p><img src="https://www.electricbike.com/wp-content/uploads/2012/06/ego-kits.jpg" alt="" /></p>

<p>You&rsquo;ve been asked to allow your system to model this new <code>Bicycle</code> variant. Perhaps you could reach for inheritance once again and end up with something like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">ElectricMotorAugmented</span> <span class="o">&lt;</span> <span class="no">Bicycle</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">drivetrain</span>
</span><span class='line'>    <span class="ss">:electric_motor</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>This may meet the needs of a relatively basic system, but let&rsquo;s say your boss asks you to run a report&hellip;</p>

<blockquote><p>Boss: &ldquo;Hey you, new gal! Get me a breakdown of all the bicycles in New York City with an approximation of their top speeds. We are examining the relationship between bicycle accidents and their drivetrain mechanism - we&rsquo;ve been hearing a lot lately about these electric-motor-augmented bicycles getting into accidents at faster speeds than non-electric bicycles.&rdquo;</p></blockquote>

<p>Since your boss seems to be asking for data concerning the relationship between bicycles&#8217; drivetrain mechanism and their approximate &lsquo;top speed&rsquo;, you set out to run the report with some code like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="no">Bicycle</span><span class="o">.</span><span class="n">all</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">bike</span><span class="o">|</span> <span class="o">[</span> <span class="n">bike</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">bike</span><span class="o">.</span><span class="n">top_speed</span> <span class="o">]</span> <span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now, you need to re-open all of your classes and implement <code>#top_speed</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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Bicycle</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">top_speed</span>
</span><span class='line'>    <span class="c1"># in units of MPH</span>
</span><span class='line'>    <span class="mi">20</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">MultiGear</span> <span class="o">&lt;</span> <span class="no">Bicycle</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">top_speed</span>
</span><span class='line'>    <span class="mi">25</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">ElectricMotorAugmented</span> <span class="o">&lt;</span> <span class="no">Bicycle</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">top_speed</span>
</span><span class='line'>    <span class="mi">30</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Gheesh, that was kind of a lot of work - we had to open 3 different classes to find a home for our top speed approximations. You can see that our pattern - which is built on top of inheritance - could certainly become unwieldy and difficult to maintain as our system grows.</p>

<h2>A better pattern: inject your dependencies!</h2>

<p>I think this pattern really speaks for itself, so I&rsquo;ll let the code do most of the talking here. Instead of inheritance, if we reached for dependency injection our system may have turned our more like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Drivetrain</span>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:freewheel</span><span class="p">,</span> <span class="ss">:gear_count</span><span class="p">,</span> <span class="ss">:electric_motor_augmented</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1"># NOTE: we&#39;re using Ruby 2.1+ required keyword argument syntax here</span>
</span><span class='line'>  <span class="c1"># https://robots.thoughtbot.com/ruby-2-keyword-arguments</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="ss">gear_count</span><span class="p">:,</span> <span class="ss">freewheel</span><span class="p">:,</span> <span class="ss">electric_motor_augmented</span><span class="p">:</span> <span class="kp">false</span><span class="p">)</span>
</span><span class='line'>    <span class="vi">@gear_count</span><span class="p">,</span> <span class="vi">@freewheel</span><span class="p">,</span> <span class="vi">@electric_motor_augmented</span> <span class="o">=</span>
</span><span class='line'>      <span class="n">gear_count</span><span class="p">,</span> <span class="n">freewheel</span><span class="p">,</span> <span class="n">electric_motor_augmented</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">top_speed</span>
</span><span class='line'>    <span class="n">speed</span> <span class="o">=</span>  <span class="p">(</span><span class="n">gear_count</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">)</span> <span class="p">?</span> <span class="mi">25</span> <span class="p">:</span> <span class="mi">20</span>
</span><span class='line'>    <span class="n">speed</span> <span class="o">+=</span> <span class="n">electric_motor_augmented</span> <span class="p">?</span> <span class="mi">10</span> <span class="p">:</span> <span class="mi">0</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">Bicycle</span>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:frame_size</span><span class="p">,</span> <span class="ss">:color</span><span class="p">,</span> <span class="ss">:drivetrain</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">frame_size</span><span class="p">,</span> <span class="n">color</span><span class="p">,</span> <span class="n">drivetrain</span> <span class="o">=</span> <span class="no">Drivetrain</span><span class="o">.</span><span class="n">new</span><span class="p">)</span>
</span><span class='line'>    <span class="vi">@frame_size</span><span class="p">,</span> <span class="vi">@color</span><span class="p">,</span> <span class="vi">@drivetrain</span> <span class="o">=</span>
</span><span class='line'>      <span class="n">frame_size</span><span class="p">,</span> <span class="n">color</span><span class="p">,</span> <span class="n">drivetrain</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">gear_count</span>
</span><span class='line'>    <span class="n">drivetrain</span><span class="o">.</span><span class="n">gear_count</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">top_speed</span>
</span><span class='line'>    <span class="n">drivetrain</span><span class="o">.</span><span class="n">top_speed</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">number_of_speeds</span>
</span><span class='line'>    <span class="n">drivetrain</span><span class="o">.</span><span class="n">freewheel</span> <span class="p">?</span> <span class="n">drivetrain</span><span class="o">.</span><span class="n">gear_count</span> <span class="p">:</span> <span class="mi">1</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now we can easily instantiate our various <code>Bicycle</code> types and get <code>#top_speed</code> data from them:</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='ruby'><span class='line'><span class="n">fixie</span>        <span class="o">=</span> <span class="no">Bicycle</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;57 cm&quot;</span><span class="p">,</span> <span class="s2">&quot;black&quot;</span><span class="p">,</span> <span class="no">Drivetrain</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">gear_count</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>  <span class="ss">freewheel</span><span class="p">:</span> <span class="kp">false</span><span class="p">))</span>
</span><span class='line'><span class="n">single_speed</span> <span class="o">=</span> <span class="no">Bicycle</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;57 cm&quot;</span><span class="p">,</span> <span class="s2">&quot;black&quot;</span><span class="p">,</span> <span class="no">Drivetrain</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">gear_count</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>  <span class="ss">freewheel</span><span class="p">:</span> <span class="kp">true</span><span class="p">))</span>
</span><span class='line'><span class="n">multi_speed</span>  <span class="o">=</span> <span class="no">Bicycle</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;57 cm&quot;</span><span class="p">,</span> <span class="s2">&quot;black&quot;</span><span class="p">,</span> <span class="no">Drivetrain</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">gear_count</span><span class="p">:</span> <span class="mi">18</span><span class="p">,</span> <span class="ss">freewheel</span><span class="p">:</span> <span class="kp">true</span><span class="p">))</span>
</span><span class='line'><span class="n">motorized</span>    <span class="o">=</span> <span class="no">Bicycle</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;57 cm&quot;</span><span class="p">,</span> <span class="s2">&quot;black&quot;</span><span class="p">,</span> <span class="no">Drivetrain</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">gear_count</span><span class="p">:</span> <span class="mi">18</span><span class="p">,</span> <span class="ss">freewheel</span><span class="p">:</span> <span class="kp">true</span><span class="p">,</span> <span class="ss">electric_motor_augmented</span><span class="p">:</span> <span class="kp">true</span><span class="p">))</span>
</span><span class='line'>
</span><span class='line'><span class="n">fixie</span><span class="o">.</span><span class="n">top_speed</span>        <span class="c1">#=&gt; 20</span>
</span><span class='line'><span class="n">single_speed</span><span class="o">.</span><span class="n">top_speed</span> <span class="c1">#=&gt; 20</span>
</span><span class='line'><span class="n">multi_speed</span><span class="o">.</span><span class="n">top_speed</span>  <span class="c1">#=&gt; 25</span>
</span><span class='line'><span class="n">motorized</span><span class="o">.</span><span class="n">top_speed</span>    <span class="c1">#=&gt; 35</span>
</span></code></pre></td></tr></table></div></figure>


<h2>&ldquo;Isolate what is different&rdquo;</h2>

<p>By isolating in our mind what was different among our bicycle variations, we were able to extract it out into its own <code>Drivetrain</code> dependency. The real benefit of doing this is that we can <em>inject</em> this dependency into our <code>Bicycle</code> instances as we need! <strong>No more sublcassing <code>Bicycle</code> endlessly as variation after variation of bike requires modeling in our system.</strong> You can envision this pattern of dependency injection coming in handy as your system grows and different attributes of <code>Bicycle</code> start to vary. Have you seen the foldable, transportable frame style of bikes?</p>

<p><img src="http://blog.tradetang.com/wp-content/uploads/2009/11/folding-bike.jpg" alt="" /></p>

<p>Using dependency injection, we can account for this variable attribute pretty succinctly:</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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Frame</span>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:color</span><span class="p">,</span> <span class="ss">:size</span><span class="p">,</span> <span class="ss">:foldable</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="ss">color</span><span class="p">:,</span> <span class="ss">size</span><span class="p">:,</span> <span class="ss">foldable</span><span class="p">:</span> <span class="kp">false</span><span class="p">)</span>
</span><span class='line'>    <span class="vi">@color</span><span class="p">,</span> <span class="vi">@size</span><span class="p">,</span> <span class="vi">@foldable</span> <span class="o">=</span> <span class="n">color</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">foldable</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">Bicycle</span>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:frame</span><span class="p">,</span> <span class="ss">:drivetrain</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">frame</span> <span class="o">=</span> <span class="no">Frame</span><span class="o">.</span><span class="n">new</span><span class="p">,</span> <span class="n">drivetrain</span> <span class="o">=</span> <span class="no">Drivetrain</span><span class="o">.</span><span class="n">new</span><span class="p">)</span>
</span><span class='line'>    <span class="vi">@frame</span><span class="p">,</span> <span class="vi">@drivetrain</span> <span class="o">=</span> <span class="n">frame</span><span class="p">,</span> <span class="n">drivetrain</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1"># rest of code omitted for brevity...</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>And here is our foldable <code>Bicycle</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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">foldable</span> <span class="o">=</span> <span class="no">Bicycle</span><span class="o">.</span><span class="n">new</span><span class="p">(</span>
</span><span class='line'>             <span class="no">Frame</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">color</span><span class="p">:</span> <span class="s2">&quot;black&quot;</span><span class="p">,</span> <span class="ss">frame_size</span><span class="p">:</span> <span class="s2">&quot;57 cm&quot;</span><span class="p">,</span> <span class="ss">foldable</span><span class="p">:</span> <span class="kp">true</span><span class="p">),</span>
</span><span class='line'>             <span class="no">Drivetrain</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="ss">gear_count</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>  <span class="ss">freewheel</span><span class="p">:</span> <span class="kp">false</span><span class="p">)</span>
</span><span class='line'><span class="p">)</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Conclusion</h2>

<p>Watching Sandi&rsquo;s talk (and writing up this post) have certainly changed my opinion on using inheritance versus injecting dependencies into my domain model. I was inspired to write this post by Sandi and the joy I&rsquo;ve been getting from riding fixie around Brooklyn for the past couple of months.</p>

<p>I hope you&rsquo;ve found this blog post interesting and educational. Please let me know in the comments below!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Using Lambdas as Computed Hashes in Ruby]]></title>
    <link href="http://mattcampbell.nyc/2015/06/18/using-lambdas-as-computed-hashes-in-ruby/"/>
    <updated>2015-06-18T11:22:00-04:00</updated>
    <id>http://mattcampbell.nyc/2015/06/18/using-lambdas-as-computed-hashes-in-ruby</id>
    <content type="html"><![CDATA[<p>I recently read a <a href="http://blog.honeybadger.io/using-lambdas-in-ruby">blurgh post</a> about the interesting, quirky aspects of lambdas in Ruby.</p>

<p>One feature that stood out to me was lambdas&#8217; ability to stand in where hashes would normally be used.</p>

<p>This functionality is made possible because, in Ruby, lambdas can be called in any of the following ways:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">l</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="nb">puts</span> <span class="n">x</span> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="n">l</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s2">&quot;Foo&quot;</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="s2">&quot;Foo&quot;</span>
</span><span class='line'><span class="n">l</span><span class="o">.</span><span class="p">(</span><span class="s2">&quot;Foo&quot;</span><span class="p">)</span>     <span class="o">=&gt;</span> <span class="s2">&quot;Foo&quot;</span> <span class="p">(</span><span class="n">admittedly</span> <span class="n">this</span> <span class="n">syntax</span> <span class="n">is</span> <span class="n">bizarre</span> <span class="n">to</span> <span class="n">me</span><span class="o">.</span><span class="n">.</span><span class="o">.</span><span class="p">)</span>
</span><span class='line'><span class="n">l</span><span class="o">[</span><span class="s2">&quot;Foo&quot;</span><span class="o">]</span>      <span class="o">=&gt;</span> <span class="s2">&quot;Foo&quot;</span> <span class="p">(</span><span class="n">looks</span> <span class="n">like</span> <span class="nb">hash</span> <span class="n">access</span> <span class="n">using</span> <span class="n">the</span> <span class="n">typical</span> <span class="no">Hash</span><span class="c1">#[] method...)</span>
</span></code></pre></td></tr></table></div></figure>


<p>The third way is the bridge between lambdas and the concept of &ldquo;computed hashes&rdquo;. I searched for a definition of computed hash, but didn&rsquo;t find much consensus. The working definition for this post would be something like:</p>

<blockquote><p>A hash object whose values can be initialized (read: computed) at runtime based on logic declared elsewhere in the program.</p></blockquote>

<h2>Putting It Together: An Example</h2>

<p>When might the use of computed hashes, i.e. lambdas, be a favorable replacement to a normal hash?</p>

<p>Let&rsquo;s say you&rsquo;re writing tests for your program and you want to add a degree of <a href="https://en.wikipedia.org/wiki/Fuzz_testing">&ldquo;fuzz testing&rdquo;</a>. As an example, perhaps one of your classes is initialized with <code>first_name</code> and <code>last_name</code> attributes (note the <code>initialize</code> method expects to receive a <code>Hash</code>-like argument as input in sticking with Rails convention), and then generates a <code>slug</code> to be used for query string parameters elsewhere in your application:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Person</span>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:first_name</span><span class="p">,</span> <span class="ss">:last_name</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">hash_like_object</span> <span class="o">=</span> <span class="p">{})</span>
</span><span class='line'>    <span class="vi">@first_name</span> <span class="o">=</span> <span class="n">hash_like_object</span><span class="o">[</span><span class="ss">:first_name</span><span class="o">]</span>
</span><span class='line'>    <span class="vi">@last_name</span>  <span class="o">=</span> <span class="n">hash_like_object</span><span class="o">[</span><span class="ss">:last_name</span><span class="o">]</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">slug</span>
</span><span class='line'>    <span class="vi">@slug</span> <span class="o">||=</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="n">first_name</span><span class="o">.</span><span class="n">downcase</span><span class="o">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="o">]</span><span class="si">}</span><span class="s2">-</span><span class="si">#{</span><span class="n">last_name</span><span class="o">.</span><span class="n">downcase</span><span class="o">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="o">]</span><span class="si">}</span><span class="s2">&quot;</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now let&rsquo;s generate an instance of the <code>Person</code> class to make sure everything looks OK:</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='bash'><span class='line'>ruby-2.2.2-p95 <span class="o">(</span>main<span class="o">)</span>:0 &gt; <span class="nv">matt</span> <span class="o">=</span> Person.new<span class="o">(</span>first_name: <span class="s2">&quot;Matt&quot;</span>, last_name: <span class="s2">&quot;Campbell&quot;</span><span class="o">)</span>
</span><span class='line'><span class="c">#&lt;Person:0x007fca00179bd0 @first_name=&quot;Matt&quot;, @last_name=&quot;Campbell&quot;&gt;</span>
</span><span class='line'>ruby-2.2.2-p95 <span class="o">(</span>main<span class="o">)</span>:0 &gt; matt.slug
</span><span class='line'><span class="s2">&quot;mat-cam&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>This checks out. Our <code>slug</code> method is pretty dumb, but let&rsquo;s say it becomes more complex: we amend <code>slug</code> to handle duplicates. As it stands, &ldquo;Arthur MacCormack&rdquo; and &ldquo;Art MacNulty&rdquo; will have the same slug and so are not uniquely identifiable by their slug.</p>

<p>The point of interest here is NOT the logic you end up implementing to make <code>slug</code> more unique. What&rsquo;s of interest is how you can fuzz test whatever logic you end up implementing throughout your test suite.</p>

<h3>Faker + Computed Hash = Fuzz Testing</h3>

<p><a href="https://github.com/stympy/faker">Faker</a> is a great library for generating random data, which I most typically use in conjunction with <a href="https://github.com/thoughtbot/factory_girl">FactoryGirl</a> to generate instances of my models (that is, the Ruby classes that represent the domain I&rsquo;m modelling in the application).</p>

<p>Let&rsquo;s see how we can utilize a computed hash to improve the degree of fuzz testing in my unit tests:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">&#39;faker&#39;</span>
</span><span class='line'>
</span><span class='line'><span class="c1"># Here is the Person class definition again for reference.</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">Person</span>
</span><span class='line'>  <span class="kp">attr_reader</span> <span class="ss">:first_name</span><span class="p">,</span> <span class="ss">:last_name</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">hash_like_object</span> <span class="o">=</span> <span class="p">{})</span>
</span><span class='line'>    <span class="c1"># The next two lines work because our hash-like-object, in some cases a lambda,</span>
</span><span class='line'>    <span class="c1"># can be called using the same [] syntax as Hash#[]</span>
</span><span class='line'>    <span class="vi">@first_name</span> <span class="o">=</span> <span class="n">hash_like_object</span><span class="o">[</span><span class="ss">:first_name</span><span class="o">]</span>
</span><span class='line'>    <span class="vi">@last_name</span>  <span class="o">=</span> <span class="n">hash_like_object</span><span class="o">[</span><span class="ss">:last_name</span><span class="o">]</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">slug</span>
</span><span class='line'>    <span class="vi">@slug</span> <span class="o">||=</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="n">first_name</span><span class="o">.</span><span class="n">downcase</span><span class="o">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="o">]</span><span class="si">}</span><span class="s2">-</span><span class="si">#{</span><span class="n">last_name</span><span class="o">.</span><span class="n">downcase</span><span class="o">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="o">]</span><span class="si">}</span><span class="s2">&quot;</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="c1"># Construct our computed hash lambda...</span>
</span><span class='line'>
</span><span class='line'><span class="n">randomizer</span> <span class="o">=</span> <span class="nb">lambda</span> <span class="p">{</span> <span class="o">|</span><span class="n">k</span><span class="o">|</span> <span class="no">Faker</span><span class="o">::</span><span class="no">Name</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="n">k</span><span class="p">)</span> <span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>And, voilà, we can initialize <code>Person</code> instances using our <code>randomizer</code> (which is in fact a lambda, and not a hash):</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='ruby'><span class='line'><span class="n">ruby</span><span class="o">-</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">-</span><span class="n">p95</span> <span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mi">0</span> <span class="o">&gt;</span> <span class="n">person</span> <span class="o">=</span> <span class="no">Person</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">randomizer</span><span class="p">)</span>
</span><span class='line'><span class="c1">#&lt;Person:0x007f81f0dfc8b0 @first_name=&quot;Nedra&quot;, @last_name=&quot;Pouros&quot;&gt;</span>
</span><span class='line'><span class="n">ruby</span><span class="o">-</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">-</span><span class="n">p95</span> <span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mi">0</span> <span class="o">&gt;</span> <span class="n">person</span><span class="o">.</span><span class="n">first_name</span>
</span><span class='line'><span class="s2">&quot;Nedra&quot;</span>
</span><span class='line'><span class="n">ruby</span><span class="o">-</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">-</span><span class="n">p95</span> <span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mi">0</span> <span class="o">&gt;</span> <span class="n">person</span><span class="o">.</span><span class="n">last_name</span>
</span><span class='line'><span class="s2">&quot;Pouros&quot;</span>
</span><span class='line'><span class="n">ruby</span><span class="o">-</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">.</span><span class="mi">2</span><span class="o">-</span><span class="n">p95</span> <span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mi">0</span> <span class="o">&gt;</span> <span class="n">person</span><span class="o">.</span><span class="n">slug</span>
</span><span class='line'><span class="s2">&quot;ned-pou&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<h2>tl;dr</h2>

<p>Need to generate pseudo-random instances of your classes in order to utilize fuzz testing across your test suite? Try initializing your instances using a computed hash, which in Ruby can be implemented using a lambda and <code>call</code>-ing it using the hash accessor <code>Hash#[]</code> that you&rsquo;re used to seeing.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Domain Modeling Mom 'N Pop Merchants in a Mobile Finance Platform]]></title>
    <link href="http://mattcampbell.nyc/2015/05/30/domain-modeling-mom-and-pop-merchants/"/>
    <updated>2015-05-30T11:04:19-04:00</updated>
    <id>http://mattcampbell.nyc/2015/05/30/domain-modeling-mom-and-pop-merchants</id>
    <content type="html"><![CDATA[<p>In my primary work project currently, I&rsquo;m working with a small startup to build a mobile finance platform for the developing world.</p>

<p>The reason: people in the developing world are largely unbanked. Estimates vary, but around <a href="http://siteresources.worldbank.org/EXTGLOBALFIN/Resources/8519638-1332259343991/world_bank3_Poster.pdf">59% of adults in developing economies don&rsquo;t have an account at a financial institution.</a> That said, using modern technologies (read: <em>really</em> cheap mobile phones, Bitcoin, and the web) it should be possible to bring banking-like services to the 2.5 billion people that use cash day-to-day almost exclusively.</p>

<h2>Where the idea of Merchants comes in to play</h2>

<p>In order to get our targeted users off cash, and onto a mobile finance platform, we need merchants in the developing world to be ready to accept payment via this mobile finance platform (which I&rsquo;ll henceforth refer to as &ldquo;MobiCommerce&rdquo; for short).</p>

<p>In many ways, &lsquo;merchants&rsquo; in our domain will be similar to everyday &lsquo;users&rsquo;, in that they&rsquo;ll be sending and receiving funds virtually via MobiCommerce.</p>

<p>Here is the <code>User</code> resource&rsquo;s schema for staters:</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='ruby'><span class='line'><span class="n">create_table</span> <span class="s2">&quot;users&quot;</span><span class="p">,</span> <span class="ss">force</span><span class="p">:</span> <span class="ss">:cascade</span> <span class="k">do</span> <span class="o">|</span><span class="n">t</span><span class="o">|</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">string</span>   <span class="s2">&quot;phone_number&quot;</span><span class="p">,</span>                        <span class="ss">null</span><span class="p">:</span> <span class="kp">false</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">datetime</span> <span class="s2">&quot;created_at&quot;</span><span class="p">,</span>                          <span class="ss">null</span><span class="p">:</span> <span class="kp">false</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">datetime</span> <span class="s2">&quot;updated_at&quot;</span><span class="p">,</span>                          <span class="ss">null</span><span class="p">:</span> <span class="kp">false</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">integer</span>  <span class="s2">&quot;status&quot;</span><span class="p">,</span>                <span class="ss">default</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span>   <span class="ss">null</span><span class="p">:</span> <span class="kp">false</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">string</span>   <span class="s2">&quot;name&quot;</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">string</span>   <span class="s2">&quot;pin&quot;</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">decimal</span>  <span class="s2">&quot;balance&quot;</span><span class="p">,</span>               <span class="ss">default</span><span class="p">:</span> <span class="mi">0</span><span class="o">.</span><span class="mi">0</span><span class="p">,</span> <span class="ss">null</span><span class="p">:</span> <span class="kp">false</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">string</span>   <span class="s2">&quot;device_id&quot;</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">integer</span>  <span class="s2">&quot;balance_inquiry_count&quot;</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">string</span>   <span class="s2">&quot;locale&quot;</span><span class="p">,</span>                              <span class="ss">null</span><span class="p">:</span> <span class="kp">false</span>
</span><span class='line'>  <span class="n">t</span><span class="o">.</span><span class="n">integer</span>  <span class="s2">&quot;referrer_id&quot;</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>The main attributes of interest for a particular <code>User</code> are <code>phone_number</code>, <code>pin</code>, and <code>balance</code> (at least insofar as executing a transaction on the platform is concerned).</p>

<h3>What&rsquo;s different about a merchant?</h3>

<p>Originally, my answer to this question was something along the lines of: &ldquo;Not that much is different. I&rsquo;ll basically just need to slightly different messages in the transaction process.&rdquo; For example, we&rsquo;re planning to charge a small fee to merchants in order to accept MobiCommerce as a payment option at their shops. So we&rsquo;d need the system to identiy that a merchant is on the receiving end of a transfer/transaction, and alert them via SMS accordingly - including notifying the merchant of the fee that will be taken out.</p>

<p>To domain model this, I first reached for <a href="http://makandracards.com/makandra/16077-inherit-without-single-table-inheritance-sti-in-activerecord">inheritance</a>:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="c1"># app/models/user/merchant.rb</span>
</span><span class='line'><span class="k">class</span> <span class="nc">User</span><span class="o">::</span><span class="no">Merchant</span> <span class="o">&lt;</span> <span class="no">User</span>
</span><span class='line'>  <span class="n">after_create</span> <span class="ss">:onboard_merchant!</span>
</span><span class='line'>  
</span><span class='line'>  <span class="kp">private</span>
</span><span class='line'>  
</span><span class='line'>  <span class="k">def</span> <span class="nf">onboard_merchant!</span>
</span><span class='line'>    <span class="no">TELEPHONY_CLIENT</span><span class="o">.</span><span class="n">send_sms</span><span class="p">(</span><span class="ss">to</span><span class="p">:</span> <span class="nb">self</span><span class="o">.</span><span class="n">phone</span><span class="p">,</span> <span class="ss">message</span><span class="p">:</span> <span class="s2">&quot;Reply with your business name&quot;</span><span class="p">,</span> <span class="ss">from</span><span class="p">:</span> <span class="nb">self</span><span class="o">.</span><span class="n">device_id</span><span class="p">)</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>However, this just felt wrong to me. Typically, subclassing an <code>ActiveRecord</code>-backed model in Rails is best for organizing a limited &amp; specific set of domain-specific behavior. The classic example is something like:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">SignUp</span> <span class="o">&lt;</span> <span class="no">User</span> <span class="p">;</span> <span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now, that <code>SignUp</code> class is a great place to put things like <code>validates :password_confirmation, presence: true</code> kinda&#8217; business logic. The term for this in Ruby is <a href="http://railscasts.com/episodes/416-form-objects">&ldquo;form models&rdquo;</a>. Any domain and/or business logic that pertains uniquely to signing up a user now has a home. This class gives you a perfect place to <a href="http://samurails.com/interview/ruby-inheritance-encapsulation-polymorphism/">encapsulate</a> that behavior.</p>

<h2>The Break Point</h2>

<p>I quickly hit a point with my <code>Merchant</code> resource where I realized it had outgrown its inheritance from the <code>User</code> class. Instead of simply adding merchant-specific business logic &amp; behaviors into this class, I found myself overwriting many of the methods inherited from <code>User</code> in order to tweak the desired behavior when a merchant was involved in a transaction.</p>

<h3>A merchant is really just a user with an associated <code>Business</code>&hellip;</h3>

<p>Thanks to my good friend <a href="https://twitter.com/creeefs">Chris Lee</a>, I arrived at a much better solution to this &ldquo;where to house my <code>Merchant</code> business logic&rdquo; predicament.</p>

<p>Remember, I originally inherited from <code>User</code> because I still needed all the logic that connected two people (merchants or non-merchants alike) doing a financial transaction - either a payment to a store, or a Venmo-style peer-to-peer transfer.</p>

<p>Chris pointed out that I could instead organize my merchant-related logic into its own model, called <code>Business</code>. Now, a &ldquo;merchant&rdquo; in my system is simply:</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='ruby'><span class='line'><span class="k">class</span> <span class="nc">User</span> <span class="o">&lt;</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
</span><span class='line'>  <span class="c1"># most code omitted...</span>
</span><span class='line'>  <span class="n">has_one</span> <span class="ss">:business</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">merchant?</span>
</span><span class='line'>    <span class="n">business</span><span class="o">.</span><span class="n">present?</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>That is, it&rsquo;s just a user instance with an associated business. Much cleaner, much more elegant, and much more expressive. Let&rsquo;s look at some examples.</p>

<p>First, this is how I can assess the merchant-specific transaction fee within my <code>Transaction</code> class:</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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Transaction</span> <span class="o">&lt;</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
</span><span class='line'>  <span class="c1"># most code omitted...</span>
</span><span class='line'>  <span class="n">belongs_to</span> <span class="ss">:sender</span><span class="p">,</span> <span class="ss">class_name</span><span class="p">:</span> <span class="no">User</span>
</span><span class='line'>  <span class="n">belongs_to</span> <span class="ss">:receiver</span><span class="p">,</span> <span class="ss">class_name</span><span class="p">:</span> <span class="no">User</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">before_create</span> <span class="ss">:assess_merchant_fee!</span><span class="p">,</span> <span class="k">if</span><span class="p">:</span> <span class="ss">:receiver_is_merchant?</span>
</span><span class='line'>
</span><span class='line'>  <span class="kp">private</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">receiver_is_merchant?</span>
</span><span class='line'>    <span class="n">receiver</span><span class="o">.</span><span class="n">merchant?</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">assess_merchant_fee!</span>
</span><span class='line'>    <span class="c1"># deduct the fee from the amount received by the merchant and notify them...</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>I was so relieved that I had a home for all of my <code>Business</code>-related logic, that I felt compelled to write this blog post. I hope you&rsquo;ve enjoyed reading it :smile:</p>

<p>P.S. From what I understand, Facebook uses this same approach to managing their Business Pages.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[How-To: Manual JSON-endpoint Testing Made Easy]]></title>
    <link href="http://mattcampbell.nyc/2014/05/27/how-to-easy-manual-testing-a-json-http-endpoint/"/>
    <updated>2014-05-27T10:25:00-04:00</updated>
    <id>http://mattcampbell.nyc/2014/05/27/how-to-easy-manual-testing-a-json-http-endpoint</id>
    <content type="html"><![CDATA[<p>Let&rsquo;s say your shiny new web application relies upon a 3rd party REST API like, say, <a href="http://www.twilio.com/docs/api/rest/response#response-formats-json">Twilio</a>. Those guys and gals do a really nice job adhering to <a href="http://stackoverflow.com/questions/671118/what-exactly-is-restful-programming">REST principles</a> when it comes to their API&rsquo;s design. But as a software developer trying to communicate with their API, what are the practical implications of having a RESTful API on the other end of the wire?</p>

<h2>Quick REST refreshment&hellip;</h2>

<p>REST is a fairly large set of principles, but for this example we&rsquo;ll focus on one aspect: The &lsquo;R&rsquo; in REST stands for &lsquo;<strong>RE</strong>presentational (<strong>S</strong>tate <strong>T</strong>ransfer)&rsquo;.</p>

<p>All URLs referenced in Twilio&rsquo;s documentation have the following base:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>https://api.twilio.com/2010-04-01
</span></code></pre></td></tr></table></div></figure>


<p>Now, we want to dig a little deeper into the &ldquo;subresources&rdquo; that Twilio exposes for our account. Take a look at the following URL endpoint (truncated for brevity):</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>https://api.twilio.com/2010-04-01/Accounts/AC228b9.../SMS/Messages/SM1f0e8ae6ade43cb3c0ce4525424e404f.json
</span></code></pre></td></tr></table></div></figure>


<p>Because the Twilio API is RESTful, we can observe the URI itself and garner quite a bit of information about the resource we&rsquo;re requesting. In this case, it&rsquo;s clearly a particular SMS instance generated by (presumably our) account ID <code>AC228b9</code>. The &ldquo;representation&rdquo; of this SMS resource is extremely intuitive, and we have REST to thank for it!</p>

<h2>&lsquo;R&rsquo; is for &lsquo;Representational&rsquo;</h2>

<p>But I want to focus now on something I haven&rsquo;t yet mentioned regarding the URL above - specifically, the <code>.json</code> suffix. RESTful APIs, like Twilio&rsquo;s, typically allow a client (e.g. web bowser, <a href="http://curl.haxx.se/download.html"><code>curl</code></a>, etc.) to request a particular representation of the desired resource. <a href="http://www.json.org/">JSON</a> has become an extremely popular such representation because, &ldquo;It is easy for humans to read and write&hellip; It is easy for machines to parse and generate.&rdquo; Given its ease-of-use and ubiquity across the interwebs, you will inevitably run into JSON endpoints as a web developer. There are many tools for working with the JSON response, but I think I may have come across one of the best strategies particularly for <a href="http://blog.jayfields.com/2014/01/repl-driven-development.html">REPL-driven development</a> and prototyping enthusiasts&hellip;</p>

<h2>Step 1: Get jq</h2>

<p><a href="https://github.com/stedolan/jq"><code>jq</code></a> is a command-line utility for parsing JSON input from STDIN (or from files, etc.; it&rsquo;s a BASH utility after all). Install it with:</p>

<p><code>brew install jq</code></p>

<p>Now, play around with it - try something like this (where <code>jq .</code> kicks off a <code>jq</code> process which waits for your input from STDIN):</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>⇒  jq .
</span><span class='line'><span class="o">{</span><span class="s2">&quot;hello&quot;</span>:<span class="s2">&quot;world&quot;</span><span class="o">}</span>
</span><span class='line'><span class="o">{</span>
</span><span class='line'>  <span class="s2">&quot;hello&quot;</span>: <span class="s2">&quot;world&quot;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Step 2: GET (via curl) your JSON endpoint</h2>

<p>There is a great resource for working with JSON called <a href="http://www.jsontest.com/">JSON Test</a>. We can easily combine one of the JSON Test endpoints with <code>curl</code> to explore the (hypothetical) JSON representation of a resource like so:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>⇒  curl -s http://headers.jsontest.com
</span><span class='line'><span class="o">{</span>
</span><span class='line'>   <span class="s2">&quot;Host&quot;</span>: <span class="s2">&quot;headers.jsontest.com&quot;</span>,
</span><span class='line'>   <span class="s2">&quot;User-Agent&quot;</span>: <span class="s2">&quot;curl/7.30.0&quot;</span>,
</span><span class='line'>   <span class="s2">&quot;Accept&quot;</span>: <span class="s2">&quot;*/*&quot;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2>Step 3: Combine steps 1 and 2 - it&rsquo;s that easy!</h2>

<p>Now that we have <code>jq</code> and <code>curl</code> down, we simply put them together by piping <code>curl</code>&rsquo;s STDOUT into the <code>jq</code> program like so:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>⇒  curl -s http://headers.jsontest.com <span class="p">|</span> jq .
</span><span class='line'><span class="o">{</span>
</span><span class='line'>  <span class="s2">&quot;Accept&quot;</span>: <span class="s2">&quot;*/*&quot;</span>,
</span><span class='line'>  <span class="s2">&quot;User-Agent&quot;</span>: <span class="s2">&quot;curl/7.30.0&quot;</span>,
</span><span class='line'>  <span class="s2">&quot;Host&quot;</span>: <span class="s2">&quot;headers.jsontest.com&quot;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>It might not look like you get much advantage by using <code>jq</code> over the standard <code>curl</code> formatted output - but <code>jq</code> really shines when you want to be able to sift through a very large JSON hash. Let&rsquo;s say you&rsquo;re reading from a <code>fake.json</code> file which contains hundreds of lines of JSON (you can take a quick look at the file <a href="https://gist.github.com/mecampbellsoup/c749e5f1b7769f57f457">in this gist</a>). That bad boy has 310 lines of JSON to be exact - <a href="https://www.youtube.com/watch?v=8cT_Ulmcrys&amp;feature=kp">ain&rsquo;t nobody got time fo&#8217; dat</a>! We can read the file and pipe the output into our trusty little friend <code>jq</code>; and then we can quickly identify, say, the first person&rsquo;s favorite fruit 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>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>⇒  jq <span class="s2">&quot;.[0].favoriteFruit&quot;</span> &lt; fake.json
</span><span class='line'><span class="s2">&quot;strawberry&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>(Note: I&rsquo;m using <code>"</code> above because <code>zsh</code> passes arguments to programs a little differently than <code>bash</code>. If using <code>bash</code>, you should be able to do simply: <code>jq .[0].favoriteFruit</code> without the quotes.)</p>

<p>By doing <code>[0]</code> I obtain the first element of the JSON array (which contains information relating to our first person); and <code>jq</code> allows me to pluck the value at a given key - in this case, the <code>favoriteFruit</code> key.</p>

<h2>Conclusion</h2>

<p>By combining <code>curl</code> with <code>jq</code>, you should never again have to struggle with manually quick-checking any server-generated JSON response that comes your way. Let me know if you found this helpful in the comments below!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[How to: Use binding.pry More Effectively Within Enumerables]]></title>
    <link href="http://mattcampbell.nyc/2013/12/07/make-debugging-with-binding-dot-pry-much-more-effective/"/>
    <updated>2013-12-07T16:02:00-05:00</updated>
    <id>http://mattcampbell.nyc/2013/12/07/make-debugging-with-binding-dot-pry-much-more-effective</id>
    <content type="html"><![CDATA[<h1>what is pry?</h1>

<p>When I first discovered the <a href="https://github.com/pry/pry">Pry gem</a>, I felt like I&rsquo;d won the lottery. At long last I had found a gem library that enabled me to simply insert a line of code - <code>binding.pry</code> - anywhere into my codebase that would drop me into an IRB session at that exact point at runtime. It sort of feels like air dropping a team of Ruby SEALs into enemy lines in order to eliminate those dreaded bugs.</p>

<h2>using pry: best practice</h2>

<p>Let&rsquo;s talk about a quick example of using Pry in a Ruby file.</p>

<p>Let&rsquo;s say you have an array of 10<sup>6</sup> elements, and you&rsquo;d like to iterate through each one and call a fancy method on it:</p>

<p>BAD USAGE OF PRY:</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='ruby'><span class='line'><span class="p">(</span><span class="mi">1</span><span class="o">.</span><span class="n">.</span><span class="mi">10</span><span class="o">**</span><span class="mi">6</span><span class="p">)</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">i</span><span class="o">|</span>
</span><span class='line'>  <span class="n">collatz</span> <span class="o">=</span> <span class="no">Collatz</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
</span><span class='line'>  <span class="n">collatz_length</span> <span class="o">=</span> <span class="n">collatz</span><span class="o">.</span><span class="n">length</span>
</span><span class='line'>  <span class="n">biggest</span> <span class="o">=</span> <span class="n">collatz</span> <span class="k">if</span> <span class="n">collatz_length</span> <span class="o">&gt;</span> <span class="n">biggest_length</span>
</span><span class='line'>  <span class="nb">binding</span><span class="o">.</span><span class="n">pry</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>In this case, I was trying to solve <a href="http://projecteuler.net/problem=14">Project Euler problem #14</a>, the Collatz sequence. At some point, I wanted to refactor my <code>Collatz#length</code> method since it was taking <strong>FOREVER</strong> to get through all one-million items in the array to find the largest sequence.</p>

<p>Man do I love Ruby. By adding just a few words of code, my bad (read: ineffective) use of Pry becomes extremely effective:</p>

<p>GOOD USAGE OF PRY:</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='ruby'><span class='line'><span class="p">(</span><span class="mi">1</span><span class="o">.</span><span class="n">.</span><span class="mi">10</span><span class="o">**</span><span class="mi">6</span><span class="p">)</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">i</span><span class="o">|</span>
</span><span class='line'>  <span class="n">collatz</span> <span class="o">=</span> <span class="no">Collatz</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
</span><span class='line'>  <span class="n">collatz_length</span> <span class="o">=</span> <span class="n">collatz</span><span class="o">.</span><span class="n">length</span>
</span><span class='line'>  <span class="n">biggest</span> <span class="o">=</span> <span class="n">collatz</span> <span class="k">if</span> <span class="n">collatz_length</span> <span class="o">&gt;</span> <span class="n">biggest_length</span>
</span><span class='line'>  <span class="nb">binding</span><span class="o">.</span><span class="n">pry</span> <span class="k">if</span> <span class="n">i</span> <span class="o">==</span> <span class="mi">100</span> <span class="o">||</span> <span class="n">i</span> <span class="o">==</span> <span class="mi">1000</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>By adding in this conditional Pry debugger, I&rsquo;m able to ensure that - as I&rsquo;m iterating through a gigantic array of a million items - I&rsquo;m getting the expected <code>Collatz</code> class behavior along the way at or around the one-hundredth &amp; one-thousandth elements, respectively.</p>

<h2>conclusion</h2>

<p>While this &ldquo;pro tip&rdquo; may have been fairly obvious to many of you Rubyists from the get-go, it didn&rsquo;t occur to me that I could treat <code>binding.pry</code> just like any other method call in Ruby&hellip; allowing me to wrap that method call into some conditional logic at runtime.</p>

<p>Thanks for reading!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Using Xcode's iOS Simulator to Build Your Next Webapp]]></title>
    <link href="http://mattcampbell.nyc/2013/11/19/using-xcodes-ios-simulator-to-build-your-next-webapp/"/>
    <updated>2013-11-19T20:19:00-05:00</updated>
    <id>http://mattcampbell.nyc/2013/11/19/using-xcodes-ios-simulator-to-build-your-next-webapp</id>
    <content type="html"><![CDATA[<h1>programmers need to be empathic</h1>

<p>When building a web application, developers need to be empathetic - that is, they need to be really good at putting themselves in their users&#8217; shoes. And these days, &ldquo;users&rdquo; aren&rsquo;t just sitting in front of a desktop anymore; instead, people take their computers everywhere with them in the form of mobile smartphones.</p>

<p>Are you in a public place? If so, look around. I mean it - really look around. What do you see? Most likely you can see people with heads lowered playing with their mobile phones.</p>

<h2>3 quick facts to convince you mobile is f*$%ing important</h2>

<ul>
<li>91% of all people on earth have a mobile phone</li>
<li>56% of people own a smart phone</li>
<li><strong>50% of mobile phone users, use mobile as their primary Internet source</strong></li>
</ul>


<p>At this point you may be thinking: &ldquo;True. I should really make sure anything I&rsquo;m building is intended for use on a smartphone.&rdquo; Kudos to you. And luckily, many of the most popular web development frameworks are way ahead of you and me in responding to the tectonic mobile shift.  <a href="http://getbootstrap.com/">Twitter Bootstrap</a> and <a href="http://foundation.zurb.com/">Zurb Foundation</a> - a pair of front-end (mainly CSS) frameworks - are representative of this shift. Both compete for the title of &ldquo;most responsive, mobile-friendly framework&rdquo; and are obsessed with offering frameworks that render beautifully regardless of the size of the computer&rsquo;s screen.</p>

<h2>&hellip;but building mobile-first can be annoying.</h2>

<p>With this in mind, in order to be an empathetic developer these days, it&rsquo;s not a bad idea to approach UI/UX with a &ldquo;mobile-first&rdquo; mentality. But &ldquo;testing&rdquo; your app in a mobile context can be pretty annoying - you need to first constantly be on your phone and using it to experiment with your app (which, if you have an iPhone like me, means goodbye battery); you are always switching back and forth between laptop and mobile device; and finally, you have to either deploy your app earlier than desired or do some extra work to set up <a href="https://github.com/progrium/localtunnel">localtunnel</a> or <a href="https://ngrok.com/">ngrok</a> in order to make your localhost server accessible to your external mobile device.</p>

<h2>Enter: iOS Simulator, a part of the Xcode development kit.</h2>

<p><a href="http://cl.ly/image/3r2i2d2P012f">Screenshot of how I use it.</a></p>

<p>This little guy solves that laundry list of problems I mentioned earlier:</p>

<ol>
<li>You never have to use your actual iPhone (preserve that precious battery)</li>
<li>As a result, no more switching back and forth and using your phone for stuff you&rsquo;d rather be doing in your natural coding environment</li>
<li>No need to deploy early or set up a localtunnel just so you can access your app&rsquo;s development environment from an iPhone</li>
</ol>


<p>And the good news keeps coming: for those of you who use Alfred (which should be anyone who spends lots of time on their computer), there&rsquo;s a workflow to make opening the iOS Simulator extremely fluid, fast and painless:</p>

<p><a href="http://cl.ly/image/0o2g0R2N201Z">Visual of using the workflow - so simple!</a></p>

<p><a href="http://www.alfredforum.com/topic/2126-launch-ios-simulator/">Here&rsquo;s a link</a> to where you can find that workflow as well.</p>

<h2>goodnight, and good luck</h2>

<p>This strategy has saved me lots of time, headache, and - especially - iPhone battery life. But more importantly, using the iOS Simulator has resulted in a more beautiful and responsive web application this time around since I was de facto engaged in the mobile experience from Day 1. (I basically never opened localhost:3000 in my web browser.) I hope you agree:</p>

<p><a href="http://bit.ly/textmelater">TextMeLater</a></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Guiding Your Users: Custom Logic in Your Rails Application's Navbar]]></title>
    <link href="http://mattcampbell.nyc/2013/11/16/custom-logic-in-your-rails-applications-navbar/"/>
    <updated>2013-11-16T18:01:00-05:00</updated>
    <id>http://mattcampbell.nyc/2013/11/16/custom-logic-in-your-rails-applications-navbar</id>
    <content type="html"><![CDATA[<h1>navbars are important</h1>

<p>Real talk: navbars are fantastic. They&rsquo;re really good at their job, which is providing a constant set of routes to your users to find their way around. No user ever gets lost when there&rsquo;s a good navbar around to help out.</p>

<p>New Rails projects ship with an application layout (that is, <code>application.html.erb</code> file) that provides an ideal home for our navbar since we want the bar to always be visible at the top of our app, and the application layour is rendered by all views by default.</p>

<p>The problem with navbars is that they typically aren&rsquo;t very intelligent. For example, when you&rsquo;re currently viewing a webpage within an application, most of the time the navigation bar does not update to hide that option dynamically. Why, oh why, would you want to click the same link twice? If you feel me on this one, keep reading&hellip;</p>

<h2>how to make your navigation bars dynamic</h2>

<p>I set out to make my navigation bar dynamic (meaning, again, that it would update its contents/links based on which view page the user was currently looking at), and found it was actually pretty straightforward thanks to inheritance in Ruby.</p>

<h3>the problem, in words</h3>

<p>Abstractly, the goal is to create some object that&rsquo;s available throughout my application, in all my controllers and views, that will contain the logic and knowledge of the last URL that the user requested. This way, if a user has just clicked, say, &ldquo;About&rdquo; on your navigation bar, the next view should not continue to show that link since it&rsquo;s become redundant.</p>

<h3>the solution, in words</h3>

<p>I know that every request hitting my application generates a new instance of the controller behind that particular endpoint. I also know that all of my controllers inherit from a master controller of sorts, which is typically <code>ApplicationController</code> in Rails. Therefore, since my other controllers - the ones actually doing the work of passing data between my models and views - inherit directly from <code>ApplicationController</code>, I figured I could write a method there that did some introspection on the most recent <code>ActionDispatch::Request</code> object in order to keep track of the last request&rsquo;s URL. In code, this strategy looked something like this:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">ApplicationController</span> <span class="o">&lt;</span> <span class="no">ActionController</span><span class="o">::</span><span class="no">Base</span>
</span><span class='line'>  <span class="kp">private</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">set_current_url</span>
</span><span class='line'>    <span class="vi">@current_path</span> <span class="o">=</span> <span class="n">request</span><span class="o">.</span><span class="n">path</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1"># rest of class omitted for brevity</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>So easy! Through this code, I now had access to the <code>@current_path</code> variable that would be available at each point in time within my views. Here is how I made use of that object (which is available via the <code>set_current_path</code> method) in my views in my application layout file:</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>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="o">&lt;</span><span class="n">nav</span> <span class="n">class</span><span class="o">=</span><span class="s2">&quot;navbar navbar-inverse&quot;</span> <span class="n">role</span><span class="o">=</span><span class="s2">&quot;navigation&quot;</span><span class="o">&gt;</span>
</span><span class='line'>  <span class="o">&lt;!--</span> <span class="no">Brand</span> <span class="ow">and</span> <span class="n">toggle</span> <span class="n">get</span> <span class="n">grouped</span> <span class="k">for</span> <span class="n">better</span> <span class="n">mobile</span> <span class="nb">display</span> <span class="o">--&gt;</span>
</span><span class='line'>  <span class="o">&lt;</span><span class="n">div</span> <span class="n">class</span><span class="o">=</span><span class="s2">&quot;navbar-header&quot;</span><span class="o">&gt;</span>
</span><span class='line'>
</span><span class='line'>    <span class="o">&lt;</span><span class="sx">% unless </span><span class="vi">@current_path</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">players_path</span><span class="p">)</span> <span class="sx">%&gt;</span>
</span><span class='line'><span class="sx">      &lt;button type=&quot;button&quot; class=&quot;btn btn-default navbar-btn&quot; data-toggle=&quot;collapse&quot; align=&quot;center&quot;&gt;</span>
</span><span class='line'>         <span class="o">&lt;</span><span class="sx">%= link_to &quot;Ladder Rankings&quot;, players_path %&gt;</span>
</span><span class='line'><span class="sx">      &lt;/button&gt;</span>
</span><span class='line'><span class="sx">    &lt;% end %&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="sx">    &lt;% unless @current_path.match(timer_path) %&gt;</span>
</span><span class='line'><span class="sx">      &lt;button type=</span><span class="s2">&quot;button&quot;</span> <span class="n">class</span><span class="o">=</span><span class="s2">&quot;btn btn-default navbar-btn&quot;</span> <span class="n">data</span><span class="o">-</span><span class="n">toggle</span><span class="o">=</span><span class="s2">&quot;collapse&quot;</span> <span class="n">align</span><span class="o">=</span><span class="s2">&quot;center&quot;</span><span class="o">&gt;</span>
</span><span class='line'>         <span class="o">&lt;</span><span class="sx">%= link_to &quot;Game Timer&quot;, timer_path %&gt;</span>
</span><span class='line'><span class="sx">      &lt;/button&gt;</span>
</span><span class='line'><span class="sx">    &lt;% end %&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="sx">    &lt;% unless @current_path =</span><span class="o">=</span> <span class="n">challenges_path</span> <span class="sx">%&gt;</span>
</span><span class='line'><span class="sx">      &lt;button type=&quot;button&quot; class=&quot;btn btn-default navbar-btn&quot; data-toggle=&quot;collapse&quot; align=&quot;center&quot;&gt;</span>
</span><span class='line'>         <span class="o">&lt;</span><span class="sx">%= link_to &quot;Battle History&quot;, challenges_path %&gt;</span>
</span><span class='line'><span class="sx">      &lt;/button&gt;</span>
</span><span class='line'><span class="sx">    &lt;% end %&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="sx">    &lt;% unless @current_path =</span><span class="o">=</span> <span class="n">new_challenge_path</span> <span class="sx">%&gt;</span>
</span><span class='line'><span class="sx">      &lt;button type=&quot;button&quot; class=&quot;btn btn-default navbar-btn&quot; data-toggle=&quot;collapse&quot; align=&quot;center&quot;&gt;</span>
</span><span class='line'>         <span class="o">&lt;%=</span> <span class="n">link_to</span> <span class="s2">&quot;Record an Outcome&quot;</span><span class="p">,</span> <span class="n">new_challenge_path</span> <span class="sx">%&gt;</span>
</span><span class='line'><span class="sx">      &lt;/button&gt;</span>
</span><span class='line'>    <span class="o">&lt;</span><span class="sx">% end %&gt;</span>
</span><span class='line'>
</span><span class='line'><span class="sx">  &lt;/div&gt;</span>
</span><span class='line'><span class="o">&lt;</span><span class="sr">/nav&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now, my navigation bar updates dynamically, presenting the user only with logical options for their next to-be-viewed page or resource in my application. Fantastic!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Running Simple Test::Unit Specs in Sublime]]></title>
    <link href="http://mattcampbell.nyc/2013/11/16/running-terse-test-unit-specs-in-sublime/"/>
    <updated>2013-11-16T11:08:00-05:00</updated>
    <id>http://mattcampbell.nyc/2013/11/16/running-terse-test-unit-specs-in-sublime</id>
    <content type="html"><![CDATA[<h1>Setting the Stage: Codewars</h1>

<p><a href="www.codewars.com/r/LqvZzw">Codewars</a> is this awesome site where you can learn Ruby or JS by training on &ldquo;katas&rdquo; and climbing the ranks of code warriors on the site. The more elegant and efficient your solution to increasingly difficult challenges, the more honor you incur.</p>

<p>I&rsquo;ve been working through a few on the Ruby side of things, and interestingly enough the Codewars team has built in to the platform <a href="http://www.codewars.com/docs/kata-test-framework">their own testing DSL</a>. It&rsquo;s sort of a mut: they&rsquo;ve borrowed all the best elements of Ruby&rsquo;s most popular frameworks, including RSpec, T::U and MiniTest. The result: for every langauga kata set on Codewars, there is a Test class/prototype (I say prototype because of JavaScript&rsquo;s unique twist on object-orientation and inheritance). Users can then easily design their own tests as instances of this parent class by invoking very natural-sounding methods like &lsquo;expect&rsquo; (from RSpec), &lsquo;assert_equal&rsquo; (from T::U), and so on.</p>

<h2>the path to enlightenment was winding</h2>

<p>Now while that sounds straightforward enough, I must confess it took me a solid couple of hours to realize that Codewars was not using a native Ruby test framework, but rather was utilizing their own testing API (and not just using some built-in T::U syntactic sugar or something):</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='ruby'><span class='line'><span class="c1"># Create your own tests here. These are some of the methods available:</span>
</span><span class='line'><span class="c1">#  Test.expect(boolean, [optional] message) </span>
</span><span class='line'><span class="c1">#  Test.assert_equals(actual, expected, [optional] message)</span>
</span><span class='line'><span class="c1">#  Test.assert_not_equals(actual, expected, [optional] message) </span>
</span></code></pre></td></tr></table></div></figure>


<p><a href="http://www.codewars.com/docs/ruby-test-reference">Here&rsquo;s the docs for the Ruby Test methods</a> that are provided by Codewars&#8217; API. Pretty fancy, huh?</p>

<h2>simpler route: use RSpec, even for miniscule test suites</h2>

<p>While I appreciate the work the Codewars guys have done on this Test module, I don&rsquo;t think learning yet another testing DSL (even though it&rsquo;s only slightly different from RSpec) makes any sense. I&rsquo;m actually a little confused as to why they would implement their own test framework in lieu of one of the already-accepted and ubiquitous frameworks like RSpec.</p>

<p>I prefer to do as close to 100% of my code-writing in Sublime as possible (practice makes perfect, ya&#8217; know?)</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Ruby's String Interpolation: Syntactic Sugar to the Max]]></title>
    <link href="http://mattcampbell.nyc/2013/10/29/string-interpolation-in-ruby/"/>
    <updated>2013-10-29T22:58:00-04:00</updated>
    <id>http://mattcampbell.nyc/2013/10/29/string-interpolation-in-ruby</id>
    <content type="html"><![CDATA[<h2>there ain&rsquo;t no such thing as magic</h2>

<p>One thing I&rsquo;ve come to realize about programming - despite almost every gut reaction to the contrary - is that there is no magic. None. Period. Fullstop. As Avi would remind us, Ruby (ignoring that whole C thing) can be distilled into three things: objects, methods, and keywords. So when you see some magic, investigate further, keeping in mind those 3 fundamental components of the Ruby language.</p>

<p><img src='http://s3.amazonaws.com/rapgenius/filepicker%2FeEF6S8NTRLu4B2LbvkwO_magic_.jpg' width=400 ></p>

<p>But as I&rsquo;ve gotten more and more exposure to Ruby&rsquo;s hidden secrets, it&rsquo;s become seemingly more difficult to believe there&rsquo;s no magic going on! This is because Ruby makes use of an idea called <a href="http://rubylearning.com/satishtalim/ruby_syntactic_sugar.html">&ldquo;syntactic sugar&rdquo;</a>. Syntactic sugar is basically a group of special programmatic syntax rules that let you write your code in a way that doesn&rsquo;t <em>appear</em> to jive with the normal rules of the language, but that is easier to remember how to do and looks better.</p>

<h2>syntactic sugar = delicious but disorienting</h2>

<p>Syntactic sugar is therefore a vehicle for abstraction. Instead of adhering only to the native syntax rules of the language, Ruby has embraced natural syntactical shortcuts that appear to break the rules, but actually make your code read more legible and human-friendly.</p>

<p>For the most part, syntactic sugar is a wonderful thing. (With a name like that, how could it <strong>not</strong> be a good thing?!) But it can also be a trifle dangerous without at least a cursory knowledge of what exactly the sugar is coating. Let&rsquo;s look at a specific example: string interpolation in Ruby.</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='ruby'><span class='line'><span class="k">def</span> <span class="nf">interpolate_two_variables</span><span class="p">(</span><span class="n">num1</span><span class="p">,</span> <span class="n">num2</span><span class="p">)</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="n">num1</span><span class="o">.</span><span class="n">class</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="n">num2</span><span class="o">.</span><span class="n">class</span>
</span><span class='line'>  <span class="s2">&quot;String interpolation allows us to magically include variables, like </span><span class="si">#{</span><span class="n">num1</span><span class="si">}</span><span class="s2"> and </span><span class="si">#{</span><span class="n">num2</span><span class="si">}</span><span class="s2">!&quot;</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="n">interpolate_two_variables</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">23</span><span class="p">)</span>
</span><span class='line'><span class="no">Fixnum</span>
</span><span class='line'><span class="no">Fixnum</span>
</span><span class='line'><span class="o">=&gt;</span> <span class="s2">&quot;String interpolation allows us to magically include variables, like 6 and 23!&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>
Sweet, thanks Ruby! I use string interpolation just about every day coding in Ruby - it&rsquo;s an incredibly powerful and convenient way to group different objects together in the context of, say, a view page in a web app. But&hellip; what&rsquo;s really going on here? I don&rsquo;t see anything like Ruby&rsquo;s normal <code>object.method_call</code> syntax, and yet it feels like there MUST be a method call being invoked inside the double quotes. What exactly is the interpreter converting the <code>#{}</code> syntax into?</p>

<h2>#{}: more than just a pretty face</h2>

<p>Assuredly, there&rsquo;s nothing magical going on here. Upon being invoked, our friend <code>#{}</code> sets to work telling the Ruby interpreter to call the <code>to_s</code> method on the object inside of itself. In the above example, those objects are <code>num1</code> and <code>num2</code>. Cool!</p>

<h2>customizing our syntactic sugar: DateTime&#8217;z</h2>

<p>This story has only just begun, y&#8217;all. Since Ruby is so awesome, we can of course (re-)define the <code>to_s</code> method at the Class level of our choosing. Consider instances of the <code>DateTime</code> class. I would like for string interpolation of DateTime instances to show up nice and legible - you know, like the way we normally communicate dates and times.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="s2">&quot;</span><span class="si">#{</span><span class="no">DateTime</span><span class="o">.</span><span class="n">now</span><span class="si">}</span><span class="s2">&quot;</span>
</span><span class='line'><span class="o">=&gt;</span> <span class="s2">&quot;2013-10-30T12:39:02-04:00&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Hmm&hellip; gross. Parsing that mentally has taken me well over the 1 microsecond that I&rsquo;ve allotted for that task. In true Ruby fashion, let&rsquo;s dive into <code>DateTime</code>&rsquo;s <code>to_s</code> method and re-write it for the task at hand:</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='ruby'><span class='line'><span class="k">class</span> <span class="nc">DateTime</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">to_s</span>
</span><span class='line'>    <span class="nb">self</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="s2">&quot;The date is %m/%d/%y, and the time is %r&quot;</span><span class="p">)</span>
</span><span class='line'>    <span class="nb">puts</span> <span class="s2">&quot;Look! </span><span class="se">\#</span><span class="s2">{} is just calling DateTime#to_s, which we overwrote to make our DateTime objects easier to read!&quot;</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'><span class="s2">&quot;</span><span class="si">#{</span><span class="no">DateTime</span><span class="o">.</span><span class="n">now</span><span class="si">}</span><span class="s2">&quot;</span>
</span><span class='line'><span class="c1"># Look! #{} is just calling DateTime#to_s, which we overwrote to make our DateTime objects easier to read!</span>
</span><span class='line'><span class="o">=&gt;</span> <span class="s2">&quot;The date is 10/30/13, and the time is 01:31:15 PM&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>This example demonstrates that the <code>#{}</code> is merely syntactic sugar that calls the <code>to_s</code> method as defined in the receiving object&rsquo;s class.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">apples</span> <span class="o">=</span> <span class="mi">4</span>
</span><span class='line'><span class="nb">puts</span> <span class="s2">&quot;I have </span><span class="si">#{</span><span class="n">apples</span><span class="si">}</span><span class="s2"> apples&quot;</span>
</span><span class='line'><span class="nb">puts</span> <span class="s2">&quot;I have %s apples&quot;</span> <span class="o">%</span> <span class="n">apples</span>
</span><span class='line'><span class="c1"># I have 4 apples</span>
</span><span class='line'><span class="o">=&gt;</span> <span class="kp">nil</span>
</span></code></pre></td></tr></table></div></figure>


<h2>main takeaways</h2>

<p>Going forward, I intend to dive head-first into every example of syntactic sugar that I can get my eyeballs on, because the sugar always coats a delicious candy core of Ruby awesomeness.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[HTTPrime: What Can We Learn About Http Request-Response From a Steakhouse?]]></title>
    <link href="http://mattcampbell.nyc/2013/10/22/the-http-steakhouse/"/>
    <updated>2013-10-22T23:34:00-04:00</updated>
    <id>http://mattcampbell.nyc/2013/10/22/the-http-steakhouse</id>
    <content type="html"><![CDATA[<h2>why must an http request be so confusing?!</h2>

<p>Look, we&rsquo;ve all been there. When first setting out to learn about the Great Internets, one of the first themes you&rsquo;ll come across is that of the HTTP request. You&rsquo;ll quickly learn that HTTP stands for &ldquo;Hypertext Transfer Protocol&rdquo;. And after mulling that over a bit, your next thought might be: &ldquo;Cool, that wasn&rsquo;t so hard!&rdquo; But soon, someone starts throwing new ideas and concepts your way - using words like &ldquo;server&rdquo;, &ldquo;web application&rdquo;, &ldquo;controllers&rdquo;, &ldquo;get&rdquo; and &ldquo;post&rdquo;. And before you know it, you&rsquo;re swimming in a sea of disconnected semantic meaning. Bummer.</p>

<p>As it turns out, the Internet is a giant, teeming and conscious (no?) mass of computers which pass long strings of text back and forth, all the time. Now, for the next part of this blog post, I could show you a picture like the following and begin to dissect it, piece by piece:</p>

<p><img src="http://www.jeevanchaaya.com/techvibe/wp-content/uploads/2008/10/http-request-response-model.png" alt="Alt text" /></p>

<h4>bring on the metaphors!</h4>

<p>But I&rsquo;m not going to subject you to that, dear reader. Today, during an impromptu mid-day comedic improvisation seminar at school (yes, Flatiron School is awesome, we know), we heard about the importance of explaining big, complicated ideas by making comparisons to things that are already understood. (That is to say, we should use more metaphors and analogies.) So instead of telling you everything there is to know about an HTTP request/response cycle, I&rsquo;m going to offer an intentionally over-simplified story for you wrapped in a familiar metaphorical context: that of a dining experience at a steakhouse.</p>

<p>Note: I&rsquo;ll be taking a tad of creative license in the coming paragraphs; turn back now if this frightens you or if you can&rsquo;t bear the idea of a steakhouse experience being in any way misrepresented.</p>

<h2>HTTPrime Steakhouse</h2>

<h4>customers are like <em>clients</em>, and the maître d&#8217; is like a <em>server</em></h4>

<p>First, let&rsquo;s set the stage. At our restaurant - the HTTPrime Steakhouse - each hopeful customer represents what&rsquo;s called a <em>client</em>. The client carries with it a very valuable thing: knowledge of what it wants! Much in the way that you enter a restaurant with knowledge of what you expect to order, an HTTP client brings that same information to a web application&rsquo;s server. In the HTTP world, all clients&#8217; requests arrive at something called a <em>server</em>, which is akin to the gatekeeping maître d&#8217; at our steakhouse. Our maître d&#8217; is responsible for intercepting potential diners, having a quick, formal chat with them to understand what they desire, and handing their request off in the appropriate manner (typically to the restaurant itself at that point, the part where customers sit and dine). I say &ldquo;formal&rdquo; chat because, in fact, the server is only able to respond with a particular type of response - integer values communicating whether the client&rsquo;s request was valid, erroneous, or misguided. Think of how a real-life maître d&#8217; feels a bit stiff when you&rsquo;re talking with him&hellip;</p>

<p>It turns out, this is very similar to the role a web server plays - the server stands at the entrance to the web application (that is, the restaurant itself), has a quick chat with incoming customers (that is, incoming HTTP requests made by clients), and passes the customers with their requests along to the waitstaff and the restaurant itself (that is, sends the HTTP request and its information along to the web application itself).</p>

<h4>GET vs. POST</h4>

<p>&ldquo;But what&rsquo;s all this jazz I keep hearing about GET and POST requests, huh?&rdquo; Great, great question. You, the client (or customer at HTTPrime, for our purposes) can actually have two types of conversations with our maître d&#8217;:</p>

<ol>
<li>Client: &ldquo;Hello sir! Could we please be seated, take a look at the menu, and <strong>GET</strong> some of your delicious filet mignon?&rdquo;</li>
<li>Client: &ldquo;Hello sir! I have a delicious filet mignon recipe to give to HTTPrime. Here you go. Maybe you could <strong>POST</strong> it up in your kitchen somewhere… that way your restaurant will have it available for all future customers.&rdquo;</li>
</ol>


<p>A GET request is akin to walking up to the maître d&#8217; and telling him you would like a filet mignon. A POST request is akin to walk up to the maître d&#8217; and telling him you have an amazing recipe for filet mignon, and you&rsquo;d like to give it to the restaurant. The maître d&#8217; then simply responds to your request by telling you whether the restaurant is prepared to handle your request.</p>

<h2>mvc&hellip; wtf?</h2>

<p><img src="http://www.digital-web.com/extras/restful_css/mvc-by-a-web-app-designer.png" alt="Alt text" /></p>

<h4>waiters are your application&rsquo;s controllers&hellip;</h4>

<p>You just wrapped up your chat with our faithful maître d&#8217;. You&rsquo;ve explained you are here to GET (should I stop capitalizing, have I driven that point home yet?) one of HTTPrime&rsquo;s famous filet mignons. What happens next: magically, out of nowhere seemingly, he summons HTTPrime&rsquo;s filet-mignon-dedicated who ushers you to your table. Let&rsquo;s call this waiter boy Rodrigo, because I think that&rsquo;s a cool name. In web applications, controllers take on the function of a restaurant&rsquo;s wait staff: they don&rsquo;t do any of the cooking, nor the cleaning up. All they do is take orders from customers, relay those orders to the kitchen (where the real magic happens), and return to the customer&rsquo;s side to fulfill their original request. I don&rsquo;t mean to trivialize the role of a good waiter - after all, bad service is almost as bad as Armageddon itself - so you can see why lightning fast, responsive controllers are a must.</p>

<h4>and the kitchen represents your application&rsquo;s models</h4>

<p>Loyal, kind, loving Rodrigo - what a big heart he has - has just confirmed your order to GET (wink, wink) a 3-pound, &ldquo;rare plus&rdquo; filet mignon. Where&rsquo;s he off to next? He&rsquo;s going to <em>control</em> that order straight over to the kitchen, of course! And as alluded to, this is where the real magic happens. In the kitchen, raw ingredients, spices, and some black magic come together to create HTTPrime&rsquo;s signature dishes - the ones that people keep comin&#8217; back for. In a web application, the models gather raw data from the database (or other data repository), sprinkle in their own sugar/spice/black magic combination (we call this &ldquo;logic&rdquo;, generally speaking), and - voilà! - pass off a perfectly cooked, delicious filet mignon for Rodrigo to satisfy you, the client&rsquo;s, picky demands.</p>

<h4>but wait, it goes deeper - down to the database</h4>

<p>But where do these raw materials come from, exactly? Well, in HTTPrime, the raw ingredients used by the kitchen would need to come from at least a couple places. (Good <a href="news:">news:</a> more metaphors coming!)</p>

<p>Every time the chef walks down to the basement where all those massive refrigerators chock full of dead animal are kept, he&rsquo;s essentially accessing our web application&rsquo;s database. Now, some fancy stuff happens in the database. And frankly, our kitchen chefs don&rsquo;t understand a lick about butchering cows, packaging the meats, and selling the raw steaks to artery-clogging steakhouse chains like ours (i.e. they don&rsquo;t speak SQL). But that&rsquo;s okay, because that isn&rsquo;t their job.</p>

<p>There&rsquo;s another way to get foodstuffs into our restaurant. If our steak database is missing some important ingredient - say, cream for the creamed spinach (my mouth is watering) - our team of chefs can go out into the world and grab the missing item from, well, anywhere. We call this &ldquo;scraping&rdquo;, and it&rsquo;s an incredibly handy tool that web developers use for getting data wherever it may be presented on the Internets. For our purposes, just keep in mind that scraping is just another way to get raw ingredients and cooking supplies into our kitchen.</p>

<h4>&hellip;and the filet&rsquo;s presentation (you know, garnish and stuff) is like the application&rsquo;s views</h4>

<p>Faithful Rodrigo has just received your freshly prepared filet from HTTPrime&rsquo;s kitchen, and he&rsquo;s heading back to where you&rsquo;re seated in the restaurant. But there&rsquo;s one problem: you, the client, are <em>extraordinarily</em> picky. In fact, you won&rsquo;t even look at a filet mignon that you&rsquo;ve ordered unless it&rsquo;s plated, garnished, and has a cherry on top. So what&rsquo;s Rodrigo to do? Well, he makes a quick pit stop at one of those waiter stations they have at fancy restaurants like HTTPrime and dresses up your filet. Literally. He puts the food-equivalent of fancy clothing on your hunk of cow.</p>

<p>Turns out, a web app&rsquo;s views are also responsible for &ldquo;dressing up&rdquo; the content that&rsquo;s delivered back to the client. Their job is to receive, via our controllers, an object (the important stuff) created by our models and make it extremely presentable. Because, after all, presentation is key - here&rsquo;s proof:</p>

<p><img src="http://4.bp.blogspot.com/-JVqw7uNjBIA/UT8iKeNvjQI/AAAAAAAAAGw/XLEljNq22Xo/s1600/best-food-presentation8.jpg" alt="Alt text" /></p>

<h4>what about the HTTP response, the back half of the request-response cycle?</h4>

<p>Actually, this component flows naturally based on what we&rsquo;ve just understood about the MVC workflow. When the waiter (our application&rsquo;s controller) finally delivers the garnished, beautified filet mignon to your table, your initial HTTP request has been fully handled and the application is issuing its response! As soon as the waiter removes his hand from the plated filet mignon and sets it before you, the request-response cycle has been completed.</p>

<h2>wrapping it up</h2>

<p>Well, that concludes this seemingly endless cycle of metaphors in metaphors inside of other metaphors. I hope this semi-realistic real-world analogy has been helpful in understanding the basic flow pattern of an HTTP request-response cycle.</p>

<p>Bon HTTP-pétit!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[What Exactly Is Between Those Pipes?]]></title>
    <link href="http://mattcampbell.nyc/2013/10/11/what-exactly-is-between-those-pipes/"/>
    <updated>2013-10-11T22:43:00-04:00</updated>
    <id>http://mattcampbell.nyc/2013/10/11/what-exactly-is-between-those-pipes</id>
    <content type="html"><![CDATA[<h3><strong>&ldquo;I&rsquo;ve seen these pipe things before… a bunch of times.&rdquo; (The thought you just had.)</strong></h3>

<p>They look super familiar. Why does Ruby make use of them? What&rsquo;s inside the pipes?!</p>

<p>Well in short, Ruby reads the thing between the pipes as a local variable to be used in the subsequent block. Let&rsquo;s look at an example of an iterator (followed by a block) from the Ruby docs.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="vi">@names</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="s2">&quot;Hello </span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">!&quot;</span> 
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>To paraphrase the docs: <code>each</code> is a method that accepts a block of code then runs that block of code for every element in a list, and the bit between <code>do</code> and <code>end</code> is just such a block. <em>The thing between pipe characters is the parameter for this block.</em></p>

<p>What happens here is that for every entry in a list (i.e. <code>@names</code> in this example), <code>name</code> is bound to that list element, and then the expression <code>puts "Hello #{name}!"</code> is run with that <code>name</code>.</p>

<p>(Thought tangent: So this example actually points to another cool feature of Ruby - &ldquo;duck typing&rdquo;. When we see <code>@names.each</code>, we naturally expect <code>@names</code> to be an Array (or Hash) and we&rsquo;ll be iterating over each element. But not so fast! What happens if <code>@names</code> is actually something totally different - like, say, an object from a custom-built class called Names? Warning: this is a highly contrived exmaple…)</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Name</span>
</span><span class='line'>  <span class="kp">attr_accessor</span> <span class="ss">:string</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
</span><span class='line'>    <span class="vi">@string</span> <span class="o">=</span> <span class="n">string</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">each</span>
</span><span class='line'>    <span class="nb">self</span><span class="o">.</span><span class="n">string</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="vi">@names</span> <span class="o">=</span> <span class="no">Name</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s2">&quot;woe, this is weird - I&#39;m a psuedo string attr within a Name object which responds to #each?!&quot;</span><span class="p">)</span>
</span><span class='line'><span class="vi">@names</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="s2">&quot;Hello </span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">&quot;</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'><span class="o">=&gt;</span> <span class="s2">&quot;woe, this is weird - I&#39;m a psuedo string within a Name object that responds to #each?!&quot;</span>
</span></code></pre></td></tr></table></div></figure>


<p>(Um, pretty awesome, right? Ruby doesn&rsquo;t care about what you expect it to do; it only cares it the object at hand responds to the method being called. Talk about an egalitarian language!)</p>

<p>Now that we&rsquo;ve had an intro-<em>duck</em>-tion to blocks and pipes, here&rsquo;s a question - how would you <em>define</em> the thing between the &ldquo;pipes&rdquo; (these guys: <code>||</code> ) in the following code example:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="n">wrecking_ball</span> <span class="o">=</span> <span class="no">Song</span><span class="o">.</span><span class="n">new</span>
</span><span class='line'><span class="n">wrecking_ball</span><span class="o">.</span><span class="n">tap</span> <span class="p">{</span> <span class="o">|</span><span class="n">song</span><span class="o">|</span> <span class="n">song</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="s2">&quot;Wrecking Ball&quot;</span> <span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>(Another mental tangent: I think pretty much every object responds to <code>#tap</code> - that will have to be for another blog post though.)</p>

<p>To put the question differently, what&rsquo;s the <code>|song|</code>? No, seriously - what is it?! Multiple choice:</p>

<ul>
<li> (a) method</li>
<li> (b) keyword</li>
<li> (c) variable</li> 
</ul>


<p>If you guessed C then you were spot on - pat yourself on the back! To be more specific, that thing between the pipes that we see in almost every block is actually a <em>local</em> variable. This is Ruby&rsquo;s approach to getting the object receiving the method call (e.g. the <code>wrecking_ball</code> Song object receiving the <code>tap</code> method) inside the method as an argument. The convo with Ruby (since we all have dialogues with our computers in the language of Ruby these days) goes down something like this:</p>

<blockquote>
&#8220;Ok lord programmer, I realize you&#8217;re calling a method on this object - and you&#8217;re hoping to &#8220;`yield&#8220;` the object receiving the method call to the method&#8217;s block (the code following the &#8220;`.each do &#8220;` bit). Tell ya&#8217; what: in order to make sure said object gets from the left side of this expression into the yielded block, I&#8217;m going to temporarily make a local variable - you can even name it WHATEVER YOU WANT - so that you have full access to the object within the block. Sound good? You bet your ass it does. I&#8217;m Ruby, we&#8217;re gonna&#8217; get along famously.&#8221;
</blockquote>


<h3>Putting down the pipe (only temorarily, calm down)</h3>

<p>Awesome. Now we know exactly what&rsquo;s going on between those pipes. Ruby is creating a local variable that points to the object receiving the method call, all so that we can fully access our object inside the method&rsquo;s block. Thanks Ruby.</p>

<p>To drive this point home, let&rsquo;s remove these pipe thingies and see if we can still code like we normally do.</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='ruby'><span class='line'><span class="n">some_numbers</span> <span class="o">=</span> <span class="o">[</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="o">]</span>
</span><span class='line'><span class="n">some_numbers</span><span class="o">.</span><span class="n">collect</span> <span class="k">do</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="s2">&quot;This is our block!&quot;</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'>
</span><span class='line'><span class="s2">&quot;This is our block!&quot;</span>
</span><span class='line'><span class="s2">&quot;This is our block!&quot;</span>
</span><span class='line'><span class="s2">&quot;This is our block!&quot;</span>
</span><span class='line'><span class="s2">&quot;This is our block!&quot;</span>
</span><span class='line'><span class="o">=&gt;</span> <span class="o">[</span><span class="kp">nil</span><span class="p">,</span><span class="kp">nil</span><span class="p">,</span><span class="kp">nil</span><span class="p">,</span><span class="kp">nil</span><span class="o">]</span>
</span></code></pre></td></tr></table></div></figure>


<p>OK, so that&rsquo;s pretty interesting. It looks like our block is definitely being evaluated, and our collect iterator is yielding to that block precisely <code>self.size</code> times (or 4 in this case). Since we have a <code>puts</code> method, whose return value is always <code>nil</code>, we end up with the returned array of <code>nil</code>&rsquo;s above. But I want access to the <code>[5,6,7,8]</code> on which we&rsquo;re calling <code>.collect</code>! Let&rsquo;s try another strategy:</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='ruby'><span class='line'><span class="n">some_numbers</span><span class="o">.</span><span class="n">collect</span> <span class="k">do</span>
</span><span class='line'>  <span class="nb">p</span> <span class="n">some_numbers</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'><span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span>
</span><span class='line'><span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span>
</span><span class='line'><span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span>
</span><span class='line'><span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span>
</span><span class='line'> <span class="o">=&gt;</span> <span class="o">[[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span><span class="p">,</span> <span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span><span class="p">,</span> <span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span><span class="p">,</span> <span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]]</span>
</span></code></pre></td></tr></table></div></figure>


<p>Alright, getting closer. Looks like we still have access to the entire object receiving the <code>.collect</code> method call. How can we get to one element of <code>some_numbers</code> at a time though? In other words, how can we get specific, granular access to each component of the object at hand, the one receiving the method call? How can we have our block be evaluated on each element of <code>some_numbers</code>, but only one element at a time? The answer lies in Ruby&rsquo;s implementation of Array#each (and really all the iterators) - here are implementations we&rsquo;ve written <a href="https://twitter.com/FlatironSchool"/>@flatironschool</a>:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">Array</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">each</span>
</span><span class='line'>    <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
</span><span class='line'>    <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">self</span><span class="o">.</span><span class="n">length</span>
</span><span class='line'>      <span class="k">yield</span><span class="p">(</span><span class="nb">self</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">)</span>
</span><span class='line'>      <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>    <span class="nb">self</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">my_each_with_index</span>
</span><span class='line'>    <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
</span><span class='line'>    <span class="k">while</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="nb">self</span><span class="o">.</span><span class="n">length</span>
</span><span class='line'>      <span class="k">yield</span><span class="p">(</span><span class="nb">self</span><span class="o">[</span><span class="n">i</span><span class="o">]</span><span class="p">,</span> <span class="n">i</span><span class="p">)</span>
</span><span class='line'>      <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
</span><span class='line'>    <span class="k">end</span>
</span><span class='line'>    <span class="nb">self</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'><span class="n">some_numbers</span> <span class="o">=</span> <span class="o">[</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="o">]</span>
</span><span class='line'><span class="n">some_numbers</span><span class="o">.</span><span class="n">my_each_with_index</span> <span class="k">do</span> <span class="o">|</span><span class="n">x</span><span class="p">,</span> <span class="n">i</span><span class="o">|</span>
</span><span class='line'>  <span class="nb">puts</span> <span class="s2">&quot;At index </span><span class="si">#{</span><span class="n">i</span><span class="si">}</span><span class="s2"> the value is </span><span class="si">#{</span><span class="n">x</span><span class="si">}</span><span class="s2">&quot;</span>
</span><span class='line'><span class="k">end</span>
</span><span class='line'><span class="no">At</span> <span class="n">index</span> <span class="mi">0</span> <span class="n">the</span> <span class="n">value</span> <span class="n">is</span> <span class="mi">5</span>
</span><span class='line'><span class="no">At</span> <span class="n">index</span> <span class="mi">1</span> <span class="n">the</span> <span class="n">value</span> <span class="n">is</span> <span class="mi">6</span>
</span><span class='line'><span class="no">At</span> <span class="n">index</span> <span class="mi">2</span> <span class="n">the</span> <span class="n">value</span> <span class="n">is</span> <span class="mi">7</span>
</span><span class='line'><span class="no">At</span> <span class="n">index</span> <span class="mi">3</span> <span class="n">the</span> <span class="n">value</span> <span class="n">is</span> <span class="mi">8</span>
</span><span class='line'><span class="o">=&gt;</span> <span class="o">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="o">]</span>
</span></code></pre></td></tr></table></div></figure>


<p>Lines 5 and 13, there&rsquo;s our old pal <code>yield</code>. How cool it is to finally see the distinction between <code>.each</code> and <code>.each_with_index</code> - it&rsquo;s merely the # of local variables from <code>self</code> (the object, in our case the <code>Array [5,6,7,8]</code> receiving the method call) that we &ldquo;yield&rdquo; or pass along to the block! Now, finally, we having a working definition of what&rsquo;s betweeen the pipes: they demarcate <strong>local variables which represent each element of <code>self</code> that get passed to the block each time our method call <code>yield</code>s to the block</strong>!</p>

<p>In my next post, I want to talk about Ruby&rsquo;s bindings - a poorly understood (and rarely needed) aspect of Ruby that I hope to shed some light on.</p>

<p>Until then: #workhard, #benice!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[A Short &amp; Sweet Intro to Objects in Ruby]]></title>
    <link href="http://mattcampbell.nyc/2013/10/08/a-short-and-sweet-intro-to-objects-in-ruby/"/>
    <updated>2013-10-08T08:25:00-04:00</updated>
    <id>http://mattcampbell.nyc/2013/10/08/a-short-and-sweet-intro-to-objects-in-ruby</id>
    <content type="html"><![CDATA[<p>Recently here at Flatiron we&rsquo;ve begun to write our code with a focus on object orientation. To a beginner, this sentence has absolutely zero meaning whatsoever - so let&rsquo;s take a step back and define some terms.</p>

<p>First of all, there are a couple truisms to keep in mind when it comes to code:</p>

<ul>
<li>First, in case you haven&#8217;t heard yet, things are going to change. Your application will grow in users; new technologies will emerge; your investors will want you to add new features (talk about a first world problem!). Your code base needs to be flexible when it comes to making changes for any of these reasons - flexible like a reed in the wind, as opposed to brittle like, say, graphite. As Sandi Metz puts it: 
<blockquote><em>
Changing requirements are the programming equivalent of friction and gravity.
</em></blockquote>
</li></ul>


<p><br>
Ok, great! So we know change is a-comin&#8217;. How do we structure our code to be prepared like the Boy Scouts?</p>

<ul>
<li>The less the different segments of your code base know about one another, the better! Admittedly, this one is a bit counterintuitive. In life, we&#8217;re typically used to setting all of our ducks in a row before taking any major steps or jumping off any cliffs (figuratively speaking, for the most part). We&#8217;re naturally pretty risk averse, and we routinely succumb to the delusion that we can mitigate risk and uncertainty a bit by lining up said ducks. It&#8217;s as if we&#8217;re trying to tear the mask of the unknown off so that we can make decisions today with perfect information. Programmers have adopted a different approach: instead of trying to know and discount the future, they simply design programs that will adapt easily, fullstop. Note I&#8217;ve made no assumption about what changes will emerge to throw our programs for a loop; the emphasis is on a coding paradigm in which your different segments can easily change how they communicate with one another. This is what people mean when they talk about the principle of object-oriented design. Once again, let&#8217;s get Sandi&#8217;s take:
<blockquote><em>
In the absence of design, unmanaged dependencies wreak havoc because objects know too muchabout one another. Changing one object forces change upon its collaborators, whichin turn, forces change upon its collaborators, ad infinitum.
</em></blockquote>
</li></ul>


<p>Now let&rsquo;s take a look at some code. Let&rsquo;s try to build a bicycle in Ruby - first we&rsquo;ll eschew the object-oriented princples just discussed, and then we&rsquo;ll embrace them. Hopefully the proof is in the pudding!</p>

<p>First, the painful, hard-to-read &amp; -follow version…</p>

<script src="https://gist.github.com/mecampbellsoup/6900628.js"></script>


<p>Whew, that was pretty exhausting and hard to follow. Let&rsquo;s see what happens if we segregate along natural, real-world dividing lines…</p>

<script src="https://gist.github.com/mecampbellsoup/6900643.js"></script>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[2 Reasons Why Larry Wall Is the Man]]></title>
    <link href="http://mattcampbell.nyc/2013/10/02/2-reasons-why-larry-wall-is-the-man/"/>
    <updated>2013-10-02T21:07:00-04:00</updated>
    <id>http://mattcampbell.nyc/2013/10/02/2-reasons-why-larry-wall-is-the-man</id>
    <content type="html"><![CDATA[<p><ol>
<li> He says things like this in <a href="http://www.wall.org/~larry/pm.html"/>speeches</a> that are ostensibly about Perl but really are about postmodernist culture and life:
<blockquote>
True greatness is measured by how much freedom you give to others, not by how much you can coerce others to do what you want.
</blockquote>
</li></p>

<p><li> He has 4 extremely intelligent children, one of whom is a postdoctorate student in physics studying BLACK HOLES.</li></p>

<p>And on that second point: his son&rsquo;s name is Aron Wall, and he wrote <a href="http://www.wall.org/~aron/horizon.htm"/>this highly readable primer</a> on black holes - what they really are, why light can&rsquo;t escape (hint: it&rsquo;s because once you/anything crosses the event horizon, the black hole moves AWAY FROM YOU/ANYTHING AT THE SPEED OF LIGHT OMFGGGGG!!!), and why they portend the next massive revolution of thought in theoretical physics as we know it.</p>

<p>Whew.</p>

<p>Thanks Larry Wall. You&rsquo;re a real mensch.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Scope in Ruby Is Like a Cell Membrane]]></title>
    <link href="http://mattcampbell.nyc/2013/10/01/scope-in-ruby-is-like-a-cell-membrane/"/>
    <updated>2013-10-01T00:03:00-04:00</updated>
    <id>http://mattcampbell.nyc/2013/10/01/scope-in-ruby-is-like-a-cell-membrane</id>
    <content type="html"><![CDATA[<h3>How is program scope like a cell membrane?</h3>

<p>Scope is the context within which something is defined. Let&rsquo;s focus on methods, for starters. If you write a page of code with a method in it, alongside a bunch of other stuff (variable declarations, enumerators/iterators not contained in that method, etc.), don&rsquo;t expect your method to have any clue what&rsquo;s going on above or below it in that page. Sorry, that explanation sucked - let me show an example:</p>

<pre><code>some_numbers = [1,2,3,4,5]
another_variable = {:cell_membrane =&gt; "cytosol", :receptor =&gt; "ligand"}
more_variables = some_numbers.collect do |num|
    num * 2
end

def method_in_same_code_file(args)
    more_variables + some_numbers ##=&gt; This method doesn't know what these are!! 
end
</code></pre>

<p>The way that we get around this issue of restrictive method scope in Ruby&rsquo;s design is actually something we all are quite familiar with: <em>passing arguments to our methods.</em> Perhaps you can imagine now the similarity to a cell membrane - take a look at the image below. I would sa the receptor-ligand binding is a lot like doing something like this:</p>

<pre><code>&lt;page of code omitted… let's just call the method&gt;
method_in_same_code_file(some_numbers, more_variables)
</code></pre>

<p>In this method call, our arguments works just like our receptor-ligand binding! Put differently: the arguments function as the cell membrane&rsquo;s receptors, in that only by going through them can stuff on the outside be itelligible/readable to the method&rsquo;s insides.</p>

<p>Method scope visualization!</p>

<p><img src="http://fwcdscience.wikispaces.com/file/view/transduction.gif/43381569/transduction.gif"></p>

<h3>cool things <a href="http://en.wikipedia.org/wiki/Kent_Beck">Kent Beck</a> has said (about programming):</h3>

<p>One line methods are there to communicate.</p>

<p>You don&rsquo;t spend three or four lines expressing iteration, you spend one word.</p>

<p>YAGNI: You aren&rsquo;t going to need it.</p>

<p>Optimism is an occupational hazard of programming; feedback is the treatment.</p>

<p>(Speaking about his Chrysler experience…) By far the dominant reason for not releasing sooner was a reluctance to trade the dream of success for the reality of feedback.</p>

<p><strong>Make it work, make it right, make it fast.</strong></p>

<h3>how to write a basic test/spec:</h3>

<pre><code>def assert_equal(actual, expected)
    unless actual == expected
        puts "fail: expected #{expected} but got #{actual}"
    end
end
</code></pre>

<p>Not so bad, right?</p>
]]></content>
  </entry>
  
</feed>