atom.xml

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

  <title><![CDATA[whazzing around]]></title>
  <link href="http://whazzing.com/atom.xml" rel="self"/>
  <link href="http://whazzing.com/"/>
  <updated>2013-12-01T17:11:12-06:00</updated>
  <id>http://whazzing.com/</id>
  <author>
    <name><![CDATA[Zachery Moneypenny]]></name>
    
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[Catching Up]]></title>
    <link href="http://whazzing.com/blog/2013/12/01/catching-up/"/>
    <updated>2013-12-01T08:45:00-06:00</updated>
    <id>http://whazzing.com/blog/2013/12/01/catching-up</id>
    <content type="html"><![CDATA[<p>Since this summer I&rsquo;ve been quite busy both at work and on local projects and
figured it was time to reflect and look towards the upcoming year.</p>

<h2>2013: The Year in Review</h2>

<p>Let&rsquo;s talk about work stuff and home stuff.</p>

<h3>@Work</h3>

<p>At work, I started 2013 as primarily a <strong>C/C++ developer</strong> working on connecting
our flagship accounting application to connected services.
It was extremely interesting, if sometimes frustrating, to enhance a 15-year-old
code base to talk to a new generation of more nimble web services. Throughout
the summer we stamped out bugs and responded to early feedback from testers, as
well as worked on merges out to all the major versions of the code base. At the
same time we started prepping documentation and transition materials to ease the
difficulty in transferring knowledge of a 20+ year-old
code base to a new team.</p>

<p>Starting in August I began splitting my time between my desktop development
tasks and my new group. I&rsquo;m now working on
<a href="http://paychecks.intuit.com">ViewMyPaycheck</a>, which is built on
<a href="http://backbonejs.org">Backbone.js</a>/HTML5/<a href="http://sass-lang.com">SCSS</a> for
the front-end and Java Web Services on the backend. It&rsquo;s really my first time
developing in Java, and so I&rsquo;m learning new things every day.</p>

<p>Luckily, due to my extensive tours of different Javascript frameworks in my
Rails projects at home I was able to come strong out of the gate in working
on the Backbone code. My experience with Sass allowed me to not only pick
up our styles quickly, but re-architect them to ease the evolution and
concurrent development by multiple engineers.</p>

<p>There was some tech debt wrapped up in the new code base but my excellent team
has thus far done a great job of prioritizing refactoring and
build/infrastructure improvements against the race to be feature-complete for
the 2013 tax season.</p>

<h3>@Home</h3>

<p>The holiday season of 2012 was quite a disaster in my family&rsquo;s annual gift
exchange. Each adult had to submit a list of things they wanted to my mom, and
then she drew the names for <strong>two</strong> different exchanges: one for our immediate
family and one for our extended family. When Xmas Morning arrived we found a
ridiculous outcome: <em>since most everyone had gone for the &lsquo;easy&rsquo; thing on their
target&rsquo;s gift list, most people received two of one thing on their list</em>.</p>

<p>It spoke to an age-old problem of holiday gift-giving where, when grandparents,
aunts, uncles, etc. all clamor for a list of things a kid wants, they have no
way of ensuring that someone else didn&rsquo;t already buy something on the list.
So in the ensuing winter, when I just so happened to have a lot of time on my
hands due to the birth of my son, I set out to create a web app to solve the
problem.</p>

<p>I finished a pre-alpha version of <a href="http://giftr.us">giftr.us</a> in the spring and
my family used it for birthdays throughout the spring and summer. It&rsquo;s in a
pretty good spot right now, but I wasn&rsquo;t able to finish the formal <strong>Gift
Exchange</strong> functionality for the 2013 Holidays.</p>

<p>This year I also began a journey to help out the
<a href="http://madrailers.org">MadRailers Meetup</a> which culminated in me taking over
the organization in the fall. I&rsquo;ve been a member of the meetup since roundabouts
shortly after I moved back from California, and it&rsquo;s enabled me to meet a ton
of great folks in the Madison tech community. I started out volunteering for
talks in the spring, and in the summer I started suggesting other topics or
speakers.  By the time of the
<a href="http://madisonruby.com">Madison Ruby conference</a> we&rsquo;d laid out a great schedule
of speakers throughout the end of the year, and I&rsquo;m really pleased with where
the group is headed and our new space: the newly-renovated
<a href="http://mynewlibrary.org/">Madison Public Library</a>!</p>

<h2>2014: The Year to Come</h2>

<h3>@Work</h3>

<p>I&rsquo;m incredibly excited to continue the modernization our Backbone app. A short
list of the changes and/or improvements I&rsquo;m planning:</p>

<ul>
<li>Move to using DevOps-provided <a href="http://www.vagrantup.com/">Vagrant</a> images on
developer machines to more closely align development and deployment
environments.</li>
<li>Move our static site code (HTML/CSS/JS/Images) to a CDN to improve load times.</li>
<li>Move from <a href="http://ant.apache.org/">Ant</a> to <a href="http://gruntjs.com">Grunt</a> to
build the site (transpile SCSS, run JS tests, etc.)</li>
<li>Move from base Backbone.js to <a href="http://marionettejs.com/">Marionette.js</a> to
get better support for composing layouts, regions, and views.</li>
<li>Router changes to better control the fetching of data.</li>
</ul>


<p>These are all technical in nature; we&rsquo;re obviously going to parallelize these
more architectural and platform-ish changes alongside the improvements to the
user workflow and enhancements based on user feedback. My ultimate goal is to
get the app into a continuously deployable build process. We&rsquo;re a ways off right
now but it&rsquo;s definitely doable.</p>

<h3>@Home</h3>

<p>I&rsquo;m going to continue to develop Giftr&rsquo;s gift exchange functionality, and I may
explore either turning it into a single-page app via Ember.js or similar, or
I may dip my toe into mobile native development. I&rsquo;m incredibly interested
in learning more about <a href="http://xamarin.com/">Xamarin</a> for doing cross-platform
mobile development.</p>

<p>I&rsquo;m also going to continue to develop more programming for MadRailers. In 2014
we&rsquo;d love to explore joint-sponsored meetups with other local tech groups,
as well as move towards more diversity in our speaker lineups and membership.
We&rsquo;ll be sponsoring more Newbie Nights as well as itermittent Hack Days.</p>

<h2>And Sooooo&hellip;</h2>

<p>It&rsquo;s been a pretty good year! I was somehow able to maintain <em>some</em> level of
progress on my own development projects even with the birth of the first kid,
and I&rsquo;m getting out of my comfort zone in my professional development which
is refreshing. Here&rsquo;s to continuing to learn and improve in 2014!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Automated ClickOnce Build and Deploy Using Powershell and MSBuild]]></title>
    <link href="http://whazzing.com/blog/2013/04/11/automated-clickonce-build-and-deploy-using-powershell-and-msbuild/"/>
    <updated>2013-04-11T12:14:00-05:00</updated>
    <id>http://whazzing.com/blog/2013/04/11/automated-clickonce-build-and-deploy-using-powershell-and-msbuild</id>
    <content type="html"><![CDATA[<p>As I was nearing completion on the <a href="">WPF app I described in an earlier post</a> I became focused on how to easily build and deploy it to our developer and QA team. I had decided to use <a href="http://en.wikipedia.org/wiki/ClickOnce">ClickOnce</a> to facilitate easy updates, but I wanted to make it dead-simple to build and deploy the installer/updater to the network share so that anyone could easily contribute to the tool development.</p>

<p>At the time I&rsquo;d been doing quite a bit of Powershell work and coincidentally I stumbled on the <a href="https://github.com/blog/1271-how-we-ship-github-for-windows">Github post</a> on how they build the <a href="http://windows.github.com/">Github for Windows application</a>. In that post I saw a tantalizing screen capture of their build/deploy script output and knew at once that I must have it.</p>

<p style="text-align:center;"><img src="http://whazzing.com/images/github-for-windows.png" height="183" width="673"/></p>


<p>From that image I reverse engineered the steps my script needed to take, and then I had to figure out how to implement each step. It&rsquo;s worth noting that <strong>ClickOnce setting manipulation and deployment is not available via scripting or MSBuild commands</strong>. The code below includes my solution to these issues.</p>

<h2>Build &amp; Deployment Script Output</h2>

<p>Below is the output of my own build and deployment script. A couple of important notes:</p>

<ul>
<li>My application consisted of one .exe file and one .dll file corresponding to two projects in a single Visual Studio solution. In the example code below I&rsquo;ve replaced my .exe project name with <strong>Executable</strong> and my .dll project name with <strong>Library</strong>. The ClickOnce settings are maintained in the Executable project file.</li>
<li><strong>I should note that a decision I made is that the installer version should always be the same as the executable version.</strong> For a small tool like this it makes things simpler than to version the installer independently of the application it installs.</li>
</ul>


<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>PS C:\dev\tools\Executable> .\Deploy.ps1
</span><span class='line'> Checking prerequisites...
</span><span class='line'> Checking out the AssemblyInfo.cs files for version increment...
</span><span class='line'> Cleaning the build directory...
</span><span class='line'> Building Executable application...
</span><span class='line'> Building ClickOnce installer...
</span><span class='line'> Deploying updates to network server...
</span><span class='line'> Comitting version increments to Perforce...
</span><span class='line'>PS C:\dev\tools\Executable></span></code></pre></td></tr></table></div></figure>


<p>The script is written to be very silent unless an error occurs, so below is a description in more detail. The script does the following:</p>

<ul>
<li>Checks to ensure that the current user has prerequisites installed (in this case perforce).</li>
<li>Checks out the appropriate files needed to increment the version number of the DLL, executable, and ClickOnce installer.</li>
<li>Cleans the build directory.</li>
<li>Builds the DLL and executable.</li>
<li>Retrieves the (file) version of the newly-build executable.</li>
<li>Forces (hacks) the executable version into the executable&rsquo;s .csproj definition of the ClickOnce settings.</li>
<li>Builds the installer with the new version and the just-built binaries.</li>
<li>Copies all of the installer files to the appropriate network fileserver.</li>
<li>Commit the changes to the AssemblyInfo and csproj files (i.e., the version changes).</li>
</ul>


<h2>Build &amp; Deployment Script</h2>

<p><strong>Please note</strong> that I&rsquo;ve changed a few things about the script below:</p>

<ul>
<li>Perforce repository paths</li>
<li>Network deployment paths</li>
<li>Binary names</li>
</ul>


<p>I&rsquo;ve included the entire (sanitized) script below, and after it describe in greater detail the interesting parts.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
<span class='line-number'>53</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>Write-Host "Tool Build/Deployment Script"
</span><span class='line'>
</span><span class='line'>$outputPrefix = " "
</span><span class='line'>$msbuild = "C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.EXE"
</span><span class='line'>
</span><span class='line'>Write-Host $outputPrefix"Checking prerequisites..."
</span><span class='line'>
</span><span class='line'>$p4Output = p4
</span><span class='line'>if($p4Output -match "'p4' is not recognized as an internal or external command")
</span><span class='line'>{
</span><span class='line'>  Write-Error "Cannot find p4.exe in your PATH."
</span><span class='line'>  Exit
</span><span class='line'>}
</span><span class='line'>
</span><span class='line'>Write-Host $outputPrefix"Checking out the AssemblyInfo.cs files for version increment..."
</span><span class='line'>p4 edit //my/project/tool/path/Library/Properties/AssemblyInfo.cs | Out-Null
</span><span class='line'>p4 edit //my/project/tool/path/Executable/Properties/AssemblyInfo.cs | Out-Null
</span><span class='line'>p4 edit //my/project/tool/path/Executable/Executable.csproj | Out-Null
</span><span class='line'>
</span><span class='line'>Write-Host $outputPrefix"Cleaning the build directory..."
</span><span class='line'>Invoke-Expression "$msbuild Executable\Executable.csproj /p:Configuration=Release /p:Platform=AnyCPU /t:clean /v:quiet /nologo"
</span><span class='line'>
</span><span class='line'>Write-Host $outputPrefix"Building Executable application..."
</span><span class='line'>Invoke-Expression "$msbuild Executable\Executable.csproj /p:Configuration=Release /p:Platform=AnyCPU /t:build /v:quiet /nologo"
</span><span class='line'>
</span><span class='line'>$newExeVersion = Get-ChildItem .\Executable\bin\Release\Executable.exe | Select-Object -ExpandProperty VersionInfo | % { $_.FileVersion }
</span><span class='line'>$newLibVersion = Get-ChildItem .\Executable\bin\Release\Library.dll | Select-Object -ExpandProperty VersionInfo | % { $_.FileVersion }
</span><span class='line'>
</span><span class='line'>Write-Host $outputPrefix"Building ClickOnce installer..."
</span><span class='line'>#
</span><span class='line'># Because the ClickOnce target doesn't automatically update or sync the application version
</span><span class='line'># with the assembly version of the EXE, we need to grab the version off of the built assembly
</span><span class='line'># and update the Executable.csproj file with the new application version.
</span><span class='line'>#
</span><span class='line'>$ProjectXml = [xml](Get-Content Executable\Executable.csproj)
</span><span class='line'>$ns = new-object Xml.XmlNamespaceManager $ProjectXml.NameTable
</span><span class='line'>$ns.AddNamespace('msb', 'http://schemas.microsoft.com/developer/msbuild/2003')
</span><span class='line'>$AppVersion = $ProjectXml.SelectSingleNode("//msb:Project/msb:PropertyGroup/msb:ApplicationVersion", $ns)
</span><span class='line'>$AppVersion.InnerText = $newExeVersion
</span><span class='line'>$TargetPath = Resolve-Path "Executable\Executable.csproj"
</span><span class='line'>$ProjectXml.Save($TargetPath)
</span><span class='line'>
</span><span class='line'>Invoke-Expression "$msbuild Executable\Executable.csproj /p:Configuration=Release /p:Platform=AnyCPU /t:publish /v:quiet /nologo"
</span><span class='line'>
</span><span class='line'>Write-Host $outputPrefix"Deploying updates to network server..."
</span><span class='line'>$LocalInstallerPath = (Resolve-Path "Executable\bin\Release\app.publish").ToString() + "\*"
</span><span class='line'>$RemoteInstallerPath = "\\network\path\Executable\DesktopClient\"
</span><span class='line'>Copy-Item $LocalInstallerPath $RemoteInstallerPath -Recurse -Force
</span><span class='line'>
</span><span class='line'>Write-Host $outputPrefix"Committing version increments to Perforce..."
</span><span class='line'>p4 submit -d "Updating Executable ClickOnce Installer to version $newExeVersion" //my/project/tool/path/Executable/Executable.csproj | Out-Null
</span><span class='line'>p4 submit -d "Updating Library to version $newLibVersion" //my/project/tool/path/Library/Properties/AssemblyInfo.cs | Out-Null
</span><span class='line'>p4 submit -d "Updating Executable to version $newExeVersion" //my/project/tool/path/Executable/Properties/AssemblyInfo.cs | Out-Null</span></code></pre></td></tr></table></div></figure>


<h3>Automated Version Increment</h3>

<p>You may have noticed that I don&rsquo;t take any specific action to manage the version numbers of Executable.exe and Library.dll even though I explicitly check out the AssemblyInfo.cs files.</p>

<p>The <a href="http://msbuildextensionpack.codeplex.com/">MSBuild Extension Pack</a> is an open-source collection of MSBuild targets that make things like version management much easier. After adding the extensions to a relative path to my projects I just needed to add the following near the bottom of <code>Executable.csproj</code>.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'><span class="nt">&lt;PropertyGroup&gt;</span>
</span><span class='line'>  <span class="nt">&lt;ExtensionTasksPath&gt;</span>..\contrib\ExtensionPack\4.0.6.0\<span class="nt">&lt;/ExtensionTasksPath&gt;</span>
</span><span class='line'><span class="nt">&lt;/PropertyGroup&gt;</span>
</span><span class='line'><span class="nt">&lt;Import</span> <span class="na">Project=</span><span class="s">&quot;$(ExtensionTasksPath)MSBuild.ExtensionPack.VersionNumber.targets&quot;</span>
</span><span class='line'>  <span class="na">Condition=</span><span class="s">&quot; &#39;$(BuildingInsideVisualStudio)&#39;!=&#39;true&#39; &quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'><span class="nt">&lt;PropertyGroup</span> <span class="na">Condition=</span><span class="s">&quot; &#39;$(BuildingInsideVisualStudio)&#39;!=&#39;true&#39; &quot;</span><span class="nt">&gt;</span>
</span><span class='line'>  <span class="nt">&lt;AssemblyMajorVersion&gt;</span>1<span class="nt">&lt;/AssemblyMajorVersion&gt;</span>
</span><span class='line'>  <span class="nt">&lt;AssemblyMinorVersion&gt;</span>3<span class="nt">&lt;/AssemblyMinorVersion&gt;</span>
</span><span class='line'>  <span class="nt">&lt;AssemblyFileMajorVersion&gt;</span>1<span class="nt">&lt;/AssemblyFileMajorVersion&gt;</span>
</span><span class='line'>  <span class="nt">&lt;AssemblyFileMinorVersion&gt;</span>3<span class="nt">&lt;/AssemblyFileMinorVersion&gt;</span>
</span><span class='line'>  <span class="nt">&lt;AssemblyInfoSpec&gt;</span>Properties\AssemblyInfo.cs<span class="nt">&lt;/AssemblyInfoSpec&gt;</span>
</span><span class='line'><span class="nt">&lt;/PropertyGroup&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>A couple things to note here:</p>

<ul>
<li>The <code>Condition</code> attributes on lines 5 &amp; 6 ensure that the version increments only occur when I run the <code>Deploy.ps1</code> script, as opposed to every time I build through the Visual Studio IDE.</li>
<li>I am holding the Major and Minor versions fixed via lines 7-10, so that only the Build and Revision numbers are auto-incremented.</li>
</ul>


<p>The above code is used <strong>both</strong> in <code>Executable.csproj</code> and <code>Library.csproj</code>, so that both the executable and the library have their version numbers managed. In doing this I can also change the major/minor versions of the executable and library independently.</p>

<h3>Propagate Exe Version to ClickOnce Installer</h3>

<p>As I mentioned earlier, I wanted to keep the installer version the same as the executable version. The problem was that there&rsquo;s no way to manage the ClickOnce settings via MSBuild or other API. Lines 35-41 of the script are the, ahem, workaround that I devised.</p>

<p>Since we want to set the ClickOnce installer version to the same as the executable, we must first fetch the executable version:</p>

<figure class='code'><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=''><span class='line'>$newExeVersion = Get-ChildItem .\Executable\bin\Release\Executable.exe | Select-Object -ExpandProperty VersionInfo | % { $_.FileVersion }</span></code></pre></td></tr></table></div></figure>


<p>This line uses the <a href="http://technet.microsoft.com/en-us/library/ee176927.aspx">powerful object piping capabilities in Powershell</a> to fetch the FileVersion property from the assembly itself.</p>

<p>Once we have the executable version, we must then somehow insert it into <code>Executable.csproj</code> where the ClickOnce settings are defined. For reference, the associated XML from the csproj file is:</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='xml'><span class='line'><span class="nt">&lt;PropertyGroup&gt;</span>
</span><span class='line'>  <span class="nt">&lt;ApplicationVersion&gt;</span>1.3.0407.01<span class="nt">&lt;/ApplicationVersion&gt;</span>
</span><span class='line'><span class="nt">&lt;/PropertyGroup&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Lines 35-41 read in the csproj file as XML and extracts the <code>ApplicationVersion</code> node. It then replaces the contents of that node with the assembly version we read from the executable and saves the entire XML structure back to the csproj file.</p>

<h2>Summary</h2>

<p>Through automating the build and deployment process I&rsquo;ve learned a lot about Powershell and MSBuild and I&rsquo;ll definitely be improving this in the future. The great thing about this particular combination of tools is that Powershell provides the glue that holds together the powerful build automation (and logging) that MSBuild offers.</p>

<p>While it&rsquo;s unfortunate that ClickOnce has so many manual aspects to it (and I think I know why) the ease of XML manipulation and file processing from Powershell make it easy to work around ClickOnce&rsquo;s lack of automation.</p>

<p>In the future I may look at moving the install/upgrade process to the <a href="http://www.wixtoolset.org/">WiX Toolset</a> as it&rsquo;s much more configurable and automatable. ClickOnce was really a stop-gap solution because it&rsquo;s for an internal tool and simple enough for my bootstrapping needs.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Responsive WPF Applications With ReactiveUI]]></title>
    <link href="http://whazzing.com/blog/2013/02/22/responsive-wpf-applications-with-reactiveui/"/>
    <updated>2013-02-22T21:25:00-06:00</updated>
    <id>http://whazzing.com/blog/2013/02/22/responsive-wpf-applications-with-reactiveui</id>
    <content type="html"><![CDATA[<p>Learn about my newfound love for the <a href="http://reactiveui.net/">ReactiveUI MVVM framework</a>.</p>

<p>My day job is to wrangle 12 million lines of 20+ year-old C and C++ using a custom Win32-based UI library that was built in the mid-90s and never fundamentally improved. It does what it was designed to do really well (bind transactions to views, zoom between list items, the transactions they compose, and the reports on those transactions) but sometimes I idly wonder what&rsquo;s been going on in bleeding edge Windows app development in the interim.</p>

<p>Last week I downloaded and played around with <a href="http://windows.github.com/">GitHub&rsquo;s excellent Windows client</a>. I vaguely remembered <a href="https://github.com/blog/1151-designing-github-for-windows">a blog post</a> on the gear underlying the desktop app awhile back, and I was interested to see where it was at these days. You know you&rsquo;re a geek when you read the entire list of licenses in the About view to get a sense of the underlying technology.</p>

<p>After looking around at the various .NET libraries involved, and reading <a href="https://github.com/blog/1127-github-for-windows">some follow-up</a> <a href="https://github.com/blog/1420-github-for-windows-recent-improvements">blog posts</a> I decided to <strong>build a front-end to a developer tool</strong> I whipped up for our developers and QA engineers at work.</p>

<p>Essentially, in debug mode QuickBooks Payroll can talk to a variety of backend environments. Configuring the various endpoints involves editing several config files that are in different places depending on whether you have an installed build or a developer build. To make it easier to configure things I wrote a command-line tool that can tell you what environments you&rsquo;re currently configured to talk to, as well as list available environments and change the current environment. I built the command-line tool on top of a library that implemented all the core logic because I knew that I&rsquo;d eventually want to build an easier-to-use GUI on top of it.</p>

<p>So as a little weekend project I took inspiration from GitHub for Windows Metro/Modern visual design and a desire to look further into ReactiveUI&rsquo;s take on multi-threaded UI.</p>

<p>Multi-threaded UI development typically has one sticking point; it&rsquo;s easy enough to define a lambda or function and set it up to run on a separate thread but one has to be very careful when moving the result of that lambda back onto the UI thread to display it. <strong>Reactive&rsquo;s</strong> secret sauce is to simplify this dangerous activity and deliver a true &lsquo;fire-and-forget&rsquo; multi-thread solution.</p>

<p>Thus far I&rsquo;ve found that it&rsquo;s very easy to chain async commands AND provide a nice responsive user experience. In cases where you have certain application behaviors that are gated upon other actions completing the ReactiveUI framework makes it extremely simple.</p>

<p>An example:</p>

<ul>
<li>App bootstraps.</li>
<li>Check for environment definition updates.</li>
<li>If updates are available; download and install updates.</li>
<li>When updates are complete, or if no updates are available then validate current saved environment settings.</li>
<li>If settings are invalid or missing show the special UI telling user to edit the app settings.</li>
<li>If settings are valid then discover the current environment.</li>
<li>Once the current environment has been determined; set the properties on the view model that are bound to the UI that describe the current environment.</li>
</ul>


<p>The state machine representing the above workflow was implemented with three View Models bound to one XAML MainWindow. The cleanest one is below, and I&rsquo;ve commented how the commands to <strong>check for updates</strong> and <strong>download and install updates</strong> are implemented (I&rsquo;m still working on tightening up the other two).</p>

<p>I&rsquo;ve included the entire file below because I think it&rsquo;s valuable to view the initialization of the commands and observers and their targets in context. This view model encapsulates all of the updater functionality and how the different states of updating are exposed to the UI.</p>

<figure class='code'><figcaption><span>EnvironmentsUpdaterViewModel.cs </span></figcaption>
<div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
<span class='line-number'>53</span>
<span class='line-number'>54</span>
<span class='line-number'>55</span>
<span class='line-number'>56</span>
<span class='line-number'>57</span>
<span class='line-number'>58</span>
<span class='line-number'>59</span>
<span class='line-number'>60</span>
<span class='line-number'>61</span>
<span class='line-number'>62</span>
<span class='line-number'>63</span>
<span class='line-number'>64</span>
<span class='line-number'>65</span>
<span class='line-number'>66</span>
<span class='line-number'>67</span>
<span class='line-number'>68</span>
<span class='line-number'>69</span>
<span class='line-number'>70</span>
<span class='line-number'>71</span>
<span class='line-number'>72</span>
<span class='line-number'>73</span>
<span class='line-number'>74</span>
<span class='line-number'>75</span>
<span class='line-number'>76</span>
<span class='line-number'>77</span>
<span class='line-number'>78</span>
<span class='line-number'>79</span>
<span class='line-number'>80</span>
<span class='line-number'>81</span>
<span class='line-number'>82</span>
<span class='line-number'>83</span>
<span class='line-number'>84</span>
<span class='line-number'>85</span>
<span class='line-number'>86</span>
<span class='line-number'>87</span>
<span class='line-number'>88</span>
<span class='line-number'>89</span>
<span class='line-number'>90</span>
<span class='line-number'>91</span>
<span class='line-number'>92</span>
<span class='line-number'>93</span>
<span class='line-number'>94</span>
<span class='line-number'>95</span>
<span class='line-number'>96</span>
<span class='line-number'>97</span>
<span class='line-number'>98</span>
<span class='line-number'>99</span>
<span class='line-number'>100</span>
<span class='line-number'>101</span>
<span class='line-number'>102</span>
<span class='line-number'>103</span>
<span class='line-number'>104</span>
<span class='line-number'>105</span>
<span class='line-number'>106</span>
<span class='line-number'>107</span>
<span class='line-number'>108</span>
<span class='line-number'>109</span>
<span class='line-number'>110</span>
<span class='line-number'>111</span>
<span class='line-number'>112</span>
<span class='line-number'>113</span>
<span class='line-number'>114</span>
<span class='line-number'>115</span>
<span class='line-number'>116</span>
<span class='line-number'>117</span>
<span class='line-number'>118</span>
<span class='line-number'>119</span>
<span class='line-number'>120</span>
<span class='line-number'>121</span>
<span class='line-number'>122</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="k">using</span> <span class="nn">System</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">System.Collections.Generic</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">System.ComponentModel</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">System.Linq</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">System.Reactive.Linq</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">System.Text</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">System.Threading.Tasks</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">Intuit.Payroll.Tools.SetPayrollEnvironment</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">ReactiveUI</span><span class="p">;</span>
</span><span class='line'><span class="k">using</span> <span class="nn">ReactiveUI.Xaml</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="k">namespace</span> <span class="nn">Intuit.Payroll.Tools.PayrollEnvironments</span>
</span><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="k">public</span> <span class="k">enum</span> <span class="n">UpdateState</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="n">Uninitialized</span><span class="p">,</span>      <span class="c1">// No action has been taken yet</span>
</span><span class='line'>        <span class="n">CheckingForUpdates</span><span class="p">,</span> <span class="c1">// Checking the update source for possible updates</span>
</span><span class='line'>        <span class="n">UpdateAvailable</span><span class="p">,</span>    <span class="c1">// An update is available for download</span>
</span><span class='line'>        <span class="n">ApplyingUpdates</span><span class="p">,</span>    <span class="c1">// Currently downloading and installing updates</span>
</span><span class='line'>        <span class="n">Completed</span>           <span class="c1">// Used when updates have completed or when no updates are available</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">public</span> <span class="k">class</span> <span class="nc">EnvironmentsUpdaterViewModel</span> <span class="p">:</span> <span class="n">ReactiveObject</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">private</span> <span class="n">PayrollEnvironmentConfiguration</span> <span class="n">_EnvConfig</span><span class="p">;</span>
</span><span class='line'>        <span class="k">private</span> <span class="n">QuickBooksInformation</span> <span class="n">_LocalSettings</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">public</span> <span class="nf">EnvironmentsUpdaterViewModel</span><span class="p">(</span><span class="n">QuickBooksInformation</span> <span class="n">localInfo</span><span class="p">)</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">_LocalSettings</span> <span class="p">=</span> <span class="n">localInfo</span><span class="p">;</span>
</span><span class='line'>            <span class="n">Status</span> <span class="p">=</span> <span class="n">_LocalSettings</span><span class="p">.</span><span class="n">IsValid</span> <span class="p">?</span> <span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">InitialUpdateMsg</span>
</span><span class='line'>                         <span class="p">:</span> <span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">InvalidSettingsUpdaterMsg</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>            <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">Uninitialized</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'>            <span class="n">InitializeConfiguration</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'>            <span class="c1">// Creating the EnvironmentsFileUpdater implicitly goes out to the update location</span>
</span><span class='line'>            <span class="c1">// (likely on a local or VPN network share), so we want to make sure it&#39;s async.</span>
</span><span class='line'>            <span class="n">CheckForUpdates</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ReactiveAsyncCommand</span><span class="p">(</span><span class="k">null</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span><span class='line'>            <span class="n">var</span> <span class="n">updaterFuture</span> <span class="p">=</span> <span class="n">CheckForUpdates</span><span class="p">.</span><span class="n">RegisterAsyncFunction</span><span class="p">(</span><span class="n">_</span> <span class="p">=&gt;</span>
</span><span class='line'>                <span class="p">{</span>
</span><span class='line'>                    <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">CheckingForUpdates</span><span class="p">;</span>
</span><span class='line'>                    <span class="k">return</span> <span class="k">new</span> <span class="nf">EnvironmentsFileUpdater</span><span class="p">(</span><span class="n">_EnvConfig</span><span class="p">);</span>
</span><span class='line'>                <span class="p">});</span>
</span><span class='line'>            <span class="n">_Updater</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ObservableAsPropertyHelper</span><span class="p">&lt;</span><span class="n">EnvironmentsFileUpdater</span><span class="p">&gt;(</span><span class="n">updaterFuture</span><span class="p">,</span> <span class="n">_</span> <span class="p">=&gt;</span> <span class="n">raisePropertyChanged</span><span class="p">(</span><span class="s">&quot;Updater&quot;</span><span class="p">));</span>
</span><span class='line'>
</span><span class='line'>            <span class="c1">// When the updater has been created, initialized and set then check if any updates</span>
</span><span class='line'>            <span class="c1">// are available on the update server.</span>
</span><span class='line'>            <span class="k">this</span><span class="p">.</span><span class="n">ObservableForProperty</span><span class="p">(</span><span class="n">x</span> <span class="p">=&gt;</span> <span class="n">x</span><span class="p">.</span><span class="n">Updater</span><span class="p">).</span><span class="n">Subscribe</span><span class="p">(</span><span class="n">_</span> <span class="p">=&gt;</span>
</span><span class='line'>                <span class="p">{</span>
</span><span class='line'>                    <span class="k">if</span> <span class="p">(</span><span class="n">Updater</span> <span class="p">!=</span> <span class="k">null</span><span class="p">)</span>
</span><span class='line'>                    <span class="p">{</span>
</span><span class='line'>                        <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">Updater</span><span class="p">.</span><span class="n">UpdateAvailable</span> <span class="p">?</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">UpdateAvailable</span> <span class="p">:</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">Completed</span><span class="p">;</span>
</span><span class='line'>                        <span class="n">Status</span> <span class="p">=</span> <span class="n">Updater</span><span class="p">.</span><span class="n">UpdateAvailable</span> <span class="p">?</span> <span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">EnvironmentUpdatesAvailableMsg</span>
</span><span class='line'>                                        <span class="p">:</span> <span class="kt">string</span><span class="p">.</span><span class="n">Format</span><span class="p">(</span><span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">CurrentEnvironmentMessage</span><span class="p">,</span> <span class="n">Updater</span><span class="p">.</span><span class="n">LatestVersion</span><span class="p">);</span>
</span><span class='line'>                        <span class="c1">// If updates are available; download and install them</span>
</span><span class='line'>                        <span class="k">if</span> <span class="p">(</span><span class="n">UpdateState</span> <span class="p">==</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">UpdateAvailable</span><span class="p">)</span>
</span><span class='line'>                        <span class="p">{</span>
</span><span class='line'>                            <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">ApplyingUpdates</span><span class="p">;</span>
</span><span class='line'>                            <span class="n">DownloadUpdates</span><span class="p">.</span><span class="n">Execute</span><span class="p">(</span><span class="k">null</span><span class="p">);</span>
</span><span class='line'>                        <span class="p">}</span>
</span><span class='line'>                    <span class="p">}</span>
</span><span class='line'>                <span class="p">});</span>
</span><span class='line'>
</span><span class='line'>            <span class="c1">// After we download and apply updates, update the status and mark the workflow as completed.</span>
</span><span class='line'>            <span class="n">DownloadUpdates</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ReactiveAsyncCommand</span><span class="p">(</span><span class="k">null</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span><span class='line'>            <span class="n">DownloadUpdates</span><span class="p">.</span><span class="n">RegisterAsyncAction</span><span class="p">(</span><span class="n">_</span> <span class="p">=&gt;</span>
</span><span class='line'>                <span class="p">{</span>
</span><span class='line'>                    <span class="k">if</span> <span class="p">(</span><span class="n">Updater</span><span class="p">.</span><span class="n">UpdateToVersion</span><span class="p">(</span><span class="n">Updater</span><span class="p">.</span><span class="n">LatestVersion</span><span class="p">))</span>
</span><span class='line'>                    <span class="p">{</span>
</span><span class='line'>                        <span class="n">Status</span> <span class="p">=</span> <span class="kt">string</span><span class="p">.</span><span class="n">Format</span><span class="p">(</span><span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">CurrentEnvironmentMessage</span><span class="p">,</span> <span class="n">Updater</span><span class="p">.</span><span class="n">LatestVersion</span><span class="p">);</span>
</span><span class='line'>                    <span class="p">}</span>
</span><span class='line'>                    <span class="k">else</span>
</span><span class='line'>                    <span class="p">{</span>
</span><span class='line'>                        <span class="n">Status</span> <span class="p">=</span> <span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">EnvironmentUpdateErrorMsg</span><span class="p">;</span>
</span><span class='line'>                    <span class="p">}</span>
</span><span class='line'>                    <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">Completed</span><span class="p">;</span>
</span><span class='line'>                <span class="p">});</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">private</span> <span class="k">void</span> <span class="nf">InitializeConfiguration</span><span class="p">()</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">try</span>
</span><span class='line'>            <span class="p">{</span>
</span><span class='line'>                <span class="n">_EnvConfig</span> <span class="p">=</span> <span class="n">EnvironmentManager</span><span class="p">.</span><span class="n">GetEnvironmentConfiguration</span><span class="p">(</span><span class="n">_LocalSettings</span><span class="p">);</span>
</span><span class='line'>            <span class="p">}</span>
</span><span class='line'>            <span class="k">catch</span> <span class="p">(</span><span class="n">Exception</span><span class="p">)</span>
</span><span class='line'>            <span class="p">{</span>
</span><span class='line'>                <span class="n">_EnvConfig</span> <span class="p">=</span> <span class="k">new</span> <span class="n">PayrollEnvironmentConfiguration</span> <span class="p">{</span> <span class="n">Version</span> <span class="p">=</span> <span class="m">0</span><span class="p">,</span>
</span><span class='line'>                                                                   <span class="n">UpdatesLocation</span> <span class="p">=</span> <span class="kt">string</span><span class="p">.</span><span class="n">Empty</span> <span class="p">};</span>
</span><span class='line'>            <span class="p">}</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">private</span> <span class="n">ObservableAsPropertyHelper</span><span class="p">&lt;</span><span class="n">EnvironmentsFileUpdater</span><span class="p">&gt;</span> <span class="n">_Updater</span><span class="p">;</span>
</span><span class='line'>        <span class="k">private</span> <span class="n">EnvironmentsFileUpdater</span> <span class="n">Updater</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">get</span> <span class="p">{</span> <span class="k">return</span> <span class="n">_Updater</span><span class="p">.</span><span class="n">Value</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="cp">#pragma warning disable 0649</span>
</span><span class='line'>        <span class="k">private</span> <span class="n">UpdateState</span> <span class="n">_UpdateState</span><span class="p">;</span>
</span><span class='line'><span class="cp">#pragma warning restore 0649</span>
</span><span class='line'>        <span class="k">public</span> <span class="n">UpdateState</span> <span class="n">UpdateState</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">get</span> <span class="p">{</span> <span class="k">return</span> <span class="n">_UpdateState</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>            <span class="k">set</span> <span class="p">{</span> <span class="k">this</span><span class="p">.</span><span class="n">RaiseAndSetIfChanged</span><span class="p">(</span><span class="k">value</span><span class="p">);</span> <span class="p">}</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="cp">#pragma warning disable 0649</span>
</span><span class='line'>        <span class="k">private</span> <span class="kt">string</span> <span class="n">_Status</span><span class="p">;</span>
</span><span class='line'><span class="cp">#pragma warning restore 0649</span>
</span><span class='line'>        <span class="k">public</span> <span class="kt">string</span> <span class="n">Status</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="k">get</span> <span class="p">{</span> <span class="k">return</span> <span class="n">_Status</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>            <span class="k">set</span> <span class="p">{</span> <span class="k">this</span><span class="p">.</span><span class="n">RaiseAndSetIfChanged</span><span class="p">(</span><span class="k">value</span><span class="p">);</span> <span class="p">}</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">public</span> <span class="n">ReactiveAsyncCommand</span> <span class="n">CheckForUpdates</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">protected</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>        <span class="k">public</span> <span class="n">ReactiveAsyncCommand</span> <span class="n">DownloadUpdates</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">protected</span> <span class="k">set</span><span class="p">;</span> <span class="p">}</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The data that the updater object fetches from is located on an intranet share, and so it was important to check for and apply updates asynchronously (especially if, like me, you&rsquo;re working over the VPN).</p>

<p>I&rsquo;m unsure at this point if it&rsquo;s ok that I&rsquo;m updating the <code>UpdateState</code> property from within many of the lambdas. I feel that there&rsquo;s something risky going on there but everything seems to work fine for me as it is.</p>

<p>I&rsquo;ll break down the two main uses of Reactive&rsquo;s async commands below. Note that I&rsquo;m using the <code>UpdateState</code> property primarily outside of this class; the window binds certain elements&#8217; visibility to the state of the updater object, but only when the state has certain values.</p>

<figure class='code'><figcaption><span>Initialize the Check for Updates Command </span></figcaption>
<div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='csharp'><span class='line'><span class="n">CheckForUpdates</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ReactiveAsyncCommand</span><span class="p">(</span><span class="k">null</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span><span class='line'><span class="n">var</span> <span class="n">updaterFuture</span> <span class="p">=</span> <span class="n">CheckForUpdates</span><span class="p">.</span><span class="n">RegisterAsyncFunction</span><span class="p">(</span><span class="n">_</span> <span class="p">=&gt;</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="c1">// Set the current state</span>
</span><span class='line'>        <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">CheckingForUpdates</span><span class="p">;</span>
</span><span class='line'>        <span class="c1">// The network access occurs in the updater constructor; this line is</span>
</span><span class='line'>        <span class="c1">// why we want this to be done asynchronously</span>
</span><span class='line'>        <span class="k">return</span> <span class="k">new</span> <span class="nf">EnvironmentsFileUpdater</span><span class="p">(</span><span class="n">_EnvConfig</span><span class="p">);</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'><span class="c1">// Connect the future object to the helper object that backs the Updater property.</span>
</span><span class='line'><span class="n">_Updater</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ObservableAsPropertyHelper</span><span class="p">&lt;</span><span class="n">EnvironmentsFileUpdater</span><span class="p">&gt;(</span><span class="n">updaterFuture</span><span class="p">,</span> <span class="n">_</span> <span class="p">=&gt;</span> <span class="n">raisePropertyChanged</span><span class="p">(</span><span class="s">&quot;Updater&quot;</span><span class="p">));</span>
</span></code></pre></td></tr></table></div></figure>


<p>When the async function returns the new <code>EnvironmentsFileUpdater</code> instance and sets the backing field of the <code>Updater</code> property, I then lean on an Observable. Below you can see that I set it up such that when the <code>Updater</code> field changes we check whether an update is available and then either kick off the <code>DownloadUpdates</code> command or set the overall state to <code>UpdateState.Completed</code> to signal to the external listeners that the update process is complete.</p>

<p>The <code>Status</code> property is the string value that&rsquo;s bound to the UI that updates the user as to what&rsquo;s happening in the update process.</p>

<figure class='code'><figcaption><span>Initialize the Updater Observer </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='csharp'><span class='line'><span class="c1">// When the updater has been created, initialized and set then check if any updates</span>
</span><span class='line'><span class="c1">// are available on the update server.</span>
</span><span class='line'><span class="k">this</span><span class="p">.</span><span class="n">ObservableForProperty</span><span class="p">(</span><span class="n">x</span> <span class="p">=&gt;</span> <span class="n">x</span><span class="p">.</span><span class="n">Updater</span><span class="p">).</span><span class="n">Subscribe</span><span class="p">(</span><span class="n">_</span> <span class="p">=&gt;</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">Updater</span> <span class="p">!=</span> <span class="k">null</span><span class="p">)</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">Updater</span><span class="p">.</span><span class="n">UpdateAvailable</span> <span class="p">?</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">UpdateAvailable</span> <span class="p">:</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">Completed</span><span class="p">;</span>
</span><span class='line'>            <span class="n">Status</span> <span class="p">=</span> <span class="n">Updater</span><span class="p">.</span><span class="n">UpdateAvailable</span> <span class="p">?</span> <span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">EnvironmentUpdatesAvailableMsg</span>
</span><span class='line'>                            <span class="p">:</span> <span class="kt">string</span><span class="p">.</span><span class="n">Format</span><span class="p">(</span><span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">CurrentEnvironmentMessage</span><span class="p">,</span> <span class="n">Updater</span><span class="p">.</span><span class="n">LatestVersion</span><span class="p">);</span>
</span><span class='line'>            <span class="c1">// If updates are available; download and install them</span>
</span><span class='line'>            <span class="k">if</span> <span class="p">(</span><span class="n">UpdateState</span> <span class="p">==</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">UpdateAvailable</span><span class="p">)</span>
</span><span class='line'>            <span class="p">{</span>
</span><span class='line'>                <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">ApplyingUpdates</span><span class="p">;</span>
</span><span class='line'>                <span class="n">DownloadUpdates</span><span class="p">.</span><span class="n">Execute</span><span class="p">(</span><span class="k">null</span><span class="p">);</span>
</span><span class='line'>            <span class="p">}</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p>The <code>DownloadUpdates</code> command actually handles the work of downloading the latest environment definitions and installing them to the appropriate local storage mechanism. Again, it must reach out over the intranet and so it&rsquo;s best to make this action asynchronous.  Most of the code you see below is concerned with updating the UI-bound status value; line 5 is the key method.</p>

<figure class='code'><figcaption><span>Initialize the Download Updates Command </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='csharp'><span class='line'><span class="n">DownloadUpdates</span> <span class="p">=</span> <span class="k">new</span> <span class="n">ReactiveAsyncCommand</span><span class="p">(</span><span class="k">null</span><span class="p">,</span> <span class="m">1</span><span class="p">);</span>
</span><span class='line'><span class="n">DownloadUpdates</span><span class="p">.</span><span class="n">RegisterAsyncAction</span><span class="p">(</span><span class="n">_</span> <span class="p">=&gt;</span>
</span><span class='line'>    <span class="p">{</span>
</span><span class='line'>        <span class="c1">// Update to the latest version of the environment definitions</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="n">Updater</span><span class="p">.</span><span class="n">UpdateToVersion</span><span class="p">(</span><span class="n">Updater</span><span class="p">.</span><span class="n">LatestVersion</span><span class="p">))</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">Status</span> <span class="p">=</span> <span class="kt">string</span><span class="p">.</span><span class="n">Format</span><span class="p">(</span><span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">CurrentEnvironmentMessage</span><span class="p">,</span> <span class="n">Updater</span><span class="p">.</span><span class="n">LatestVersion</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>        <span class="k">else</span>
</span><span class='line'>        <span class="p">{</span>
</span><span class='line'>            <span class="n">Status</span> <span class="p">=</span> <span class="n">Properties</span><span class="p">.</span><span class="n">Resources</span><span class="p">.</span><span class="n">EnvironmentUpdateErrorMsg</span><span class="p">;</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>        <span class="c1">// Finalize the state of the update process</span>
</span><span class='line'>        <span class="n">UpdateState</span> <span class="p">=</span> <span class="n">UpdateState</span><span class="p">.</span><span class="n">Completed</span><span class="p">;</span>
</span><span class='line'>    <span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p>I hope this has been a decent non-trivial example on how to use the ReactiveUI framework to build WPF view models; if it looks interesting have a look at the <a href="http://reactiveui.net/welcome/pdf">great docs</a> that have been synthesized from <a href="http://blog.paulbetts.org/">Paul Betts blog post examples</a> of different usages of the framework.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Fitbit Logins via Omniauth in Rails]]></title>
    <link href="http://whazzing.com/blog/2012/12/31/twitter-and-facebook-logins-via-omniauth-in-rails/"/>
    <updated>2012-12-31T10:54:00-06:00</updated>
    <id>http://whazzing.com/blog/2012/12/31/twitter-and-facebook-logins-via-omniauth-in-rails</id>
    <content type="html"><![CDATA[<p>It all started with a <a href="http://whazzing.com/blog/2012/03/20/becoming-the-finisher/#comment-743146618">comment</a> and a <a href="https://github.com/whazzmaster/fitgem-client/pull/4">pull request</a>.</p>

<p>I hadn&rsquo;t put time into maintaining my <a href="http://github.com/whazzmaster/fitgem">fitbit gem</a> <a href="http://www.fitbitclient.com">reference app</a> in quite awhile, and when I got a pull request to update it to the latest rails version I at first hesitated. After talking with some folks at <a href="http://www.bendyworks.com">my coworking space</a>, however, I decided to use some holiday downtime to pull in the changes and see if I could build on them to improve the quality of the site.</p>

<p>At first I was horrified to learn that I&rsquo;d stopped in mid-refactoring and I realized it was no wonder that Marcel (the submitter) reported he&rsquo;d had trouble getting tests to run. The first step was to delete whole directories of files and tests that no longer conformed to the current design of the site and ensure that the files that remained all contributed to that design.</p>

<p>I grabbed Marcel&rsquo;s pull request and got to work merging it in, at which point I looked at the login code and got embarrassed again. The truth is, the <a href="http://github.com/whazzmaster/fitgem">fitgem</a> library wasn&rsquo;t really built for managing oauth logins; instead it is optimized for using a token/secret for a given user to fetch data from the API. Yes, you could use fitgem to facilitate an oauth login process, but it certainly wasn&rsquo;t built with rails in mind and you had to roll your own controllers, views, and token and secret management.</p>

<p>The thing is, we already have a library that does that sort of thing: <a href="https://github.com/intridea/omniauth">OmniAuth</a> is a fantastic library for consuming <a href="https://github.com/intridea/omniauth/wiki/List-of-Strategies">pluggable login strategies</a>. I didn&rsquo;t have to search long before I found a <a href="https://github.com/tkgospodinov/omniauth-fitbit">fitbit strategy for omniauth</a>, and I set to work integrating it into the reference app.</p>

<p>Luckily I had been working a lot with OmniAuth lately, as I&rsquo;d implemented logins via Facebook and Twitter in another project just the week before. As always I leaned heavily on Ryan Bates&#8217; excellent <a href="http://railscasts.com">Railscasts</a> in getting up to speed on how <a href="http://railscasts.com/episodes/235-devise-and-omniauth-revised">OmniAuth worked with Devise</a>, and specifically with Twitter and <a href="http://railscasts.com/episodes/360-facebook-authentication">Facebook</a>. &lt;small-plug&gt;Railscasts Pro ($9/month) has been totally worth it for me. The Pro episodes go into a lot of depth and I&rsquo;ve learned a ton from them.&lt;/small-plug&gt;</p>

<p>Using the omniauth-fitbit gem I was able to delete a lot of now-redundant code for signing into/up for the application. There were, however, a few hiccups along the way that I wanted to note:</p>

<ul>
<li>Unlike Twitter and Facebook, logging into Fitbit via omniauth-fitbit doesn&rsquo;t allow devise to remember you from session to session, so you end having to re-login every time. I haven&rsquo;t yet figured out why but it may be something about how Fitbit conducts OAuth logins or it may be a configuration issue with omniauth-fitbit.</li>
<li>Logging in via Fitbit is fine and dandy, but if you want to use the token/secret for the logged-in user to fetch data from the API through the fitgem interface you&rsquo;ll need to store them. I just added fields to my user object:</li>
</ul>


<figure class='code'><figcaption><span>Add Oauth fields to User model</span><a href='https://github.com/whazzmaster/fitgem-client/blob/master/db/migrate/20121225193557_add_oauth_fields_to_users.rb'>_add_oauth_fields_to_users.rb </a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="k">class</span> <span class="nc">AddOauthFieldsToUsers</span> <span class="o">&lt;</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Migration</span>
</span><span class='line'>  <span class="k">def</span> <span class="nf">change</span>
</span><span class='line'>    <span class="n">add_column</span> <span class="ss">:users</span><span class="p">,</span> <span class="ss">:oauth_token</span><span class="p">,</span> <span class="ss">:string</span>
</span><span class='line'>    <span class="n">add_column</span> <span class="ss">:users</span><span class="p">,</span> <span class="ss">:oauth_secret</span><span class="p">,</span> <span class="ss">:string</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>


<ul>
<li>I made some, ahem, unorthodox decisions that will have to refactored later. Chief among them was to add the FitbitClient to the User model:</li>
</ul>


<figure class='code'><figcaption><span>Access to FitbitClient through User model</span><a href='https://github.com/whazzmaster/fitgem-client/blob/master/app/models/user.rb'>user.rb </a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
</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><span class='line'>  <span class="c1"># Elided for conciseness</span>
</span><span class='line'>
</span><span class='line'>  <span class="k">def</span> <span class="nf">linked?</span>
</span><span class='line'>    <span class="n">oauth_token</span><span class="o">.</span><span class="n">present?</span> <span class="o">&amp;&amp;</span> <span class="n">oauth_secret</span><span class="o">.</span><span class="n">present?</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">fitbit_data</span>
</span><span class='line'>    <span class="k">raise</span> <span class="s2">&quot;Account is not linked with a Fitbit account&quot;</span> <span class="k">unless</span> <span class="n">linked?</span>
</span><span class='line'>    <span class="vi">@client</span> <span class="o">||=</span> <span class="no">Fitgem</span><span class="o">::</span><span class="no">Client</span><span class="o">.</span><span class="n">new</span><span class="p">(</span>
</span><span class='line'>                <span class="ss">:consumer_key</span> <span class="o">=&gt;</span> <span class="no">ENV</span><span class="o">[</span><span class="s2">&quot;FITBIT_CONSUMER_KEY&quot;</span><span class="o">]</span><span class="p">,</span>
</span><span class='line'>                <span class="ss">:consumer_secret</span> <span class="o">=&gt;</span> <span class="no">ENV</span><span class="o">[</span><span class="s2">&quot;FITBIT_CONSUMER_SECRET&quot;</span><span class="o">]</span><span class="p">,</span>
</span><span class='line'>                <span class="ss">:token</span> <span class="o">=&gt;</span> <span class="n">oauth_token</span><span class="p">,</span>
</span><span class='line'>                <span class="ss">:secret</span> <span class="o">=&gt;</span> <span class="n">oauth_secret</span><span class="p">,</span>
</span><span class='line'>                <span class="ss">:user_id</span> <span class="o">=&gt;</span> <span class="n">uid</span>
</span><span class='line'>              <span class="p">)</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">has_fitbit_data?</span>
</span><span class='line'>    <span class="o">!</span><span class="vi">@client</span><span class="o">.</span><span class="n">nil?</span>
</span><span class='line'>  <span class="k">end</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1"># Elided for conciseness</span>
</span><span class='line'>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>


<p>Eventually I should use a better pattern for this, but for now it&rsquo;s simplistic and anywhere you have a logged-in user in your application you will be able to call <code>fitbit_data</code> to get access to a configured FitbitClient instance.</p>

<p>And with that we&rsquo;re logging in via Fitbit and using the token/secret returned via omniuath-fitbit to fuel data retrieval from the Fitbit API through fitgem.</p>

<h3>List of Resources</h3>

<ul>
<li><a href="https://github.com/intridea/omniauth">OmniAuth</a>: Base authentication library</li>
<li><a href="https://github.com/tkgospodinov/omniauth-fitbit">omniauth-fitbit</a>: Fitbit-specific pluggable OmniAuth strategy</li>
<li><a href="http://github.com/whazzmaster/fitgem">fitgem</a>: Fitbit API library</li>
<li>Fitgem Reference Application (<a href="http://fitbitclient.com">app</a>|<a href="https://github.com/whazzmaster/fitgem-client">code</a>): An example application using omniauth-fitbit and fitgem</li>
<li><a href="http://dev.fitbit.com">Fitbit.com Developer Site</a>: Manage your developer keys for use with omniauth-fitbit and fitgem</li>
<li><a href="http://railscasts.com/episodes/235-devise-and-omniauth-revised">OmniAuth and Devise Railscast</a>: Integrating OmniAuth, Devise, and Twitter</li>
<li><a href="http://railscasts.com/episodes/360-facebook-authentication">Facebook Authentication with OmniAuth Railscast</a>: Setting up OmniAuth to work with Facebook</li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[I Seem to Be Getting Along Fine Without Facebook]]></title>
    <link href="http://whazzing.com/blog/2012/11/26/i-seem-to-be-getting-along-fine-without-facebook/"/>
    <updated>2012-11-26T20:24:00-06:00</updated>
    <id>http://whazzing.com/blog/2012/11/26/i-seem-to-be-getting-along-fine-without-facebook</id>
    <content type="html"><![CDATA[<p>I&rsquo;m trying <strong>really</strong> hard to not read Hacker News these days, as the contrarian argument-for-argument&rsquo;s-sake nature of the comments tends to enrage me, but one of the more mystifying memes that seems to persist down in the Comments Dungeon is that the social contract of the United States of America requires you to be on Facebook.</p>

<p>In each thread where the topic appears there&rsquo;s someone that says &ldquo;I wish I didn&rsquo;t have to have a Facebook account but unfortunately it&rsquo;s required.&rdquo;  Someone responds and notes that no, <strong>it&rsquo;s not required</strong>, and all they have to do is delete their account.  That (sensible) response is then responded to a million times with the now-ubiquitous oath: to be a fully-fledged member of a social group in 2012 requires one to be on Facebook.  And to that I restate the obvious: no, it really isn&rsquo;t.</p>

<p>How many devices do you use on a daily basis? Phones, laptops, tablets, desktops, kiosks, and more.  There exists a whole world outside of Facebook and all you have to do is grasp it.  I prefer phone calls or coffee with friends over email but it&rsquo;ll do in a pinch.  I share my photos through Flickr and Twitter (depending on whether they came from my DSLR or iPhone).  I blog at a skrillion different venues.  People know where to find me online and IRL, and I&rsquo;m confident that within my social circle I won&rsquo;t be left off some invite just because I&rsquo;m not on Facebook.  My friends are my friends&mdash; we enjoy each others&#8217; company!  What I found when I deleted my Facebook account was that none of my friends really used it for anything meaningful.  My wall was eternally filled with high school people I hadn&rsquo;t seen/talked to/cared about in a decade, and extended family that I didn&rsquo;t talk to much anyways.</p>

<p>In the last 5 years I&rsquo;ve taken two significant (though very First-World-Problemy) steps: I got rid of my car, and I deleted my Facebook account.  Interestingly enough <strong>at the time I did each of these things</strong> I was much more uncomfortable and worried about having no car than that I would miss some crucial social interaction by leaving Facebook.</p>

<p>When I left Facebook there was much more a sense of relief than anything else; <strong>I suggest you try it</strong>.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Madison Ruby 2012]]></title>
    <link href="http://whazzing.com/blog/2012/08/27/madison-ruby-2012/"/>
    <updated>2012-08-27T17:04:00-05:00</updated>
    <id>http://whazzing.com/blog/2012/08/27/madison-ruby-2012</id>
    <content type="html"><![CDATA[<p><em>Please note</em>: Madison Ruby photos are now online at <a href="http://www.flickr.com/photos/whazzmaster/sets/72157631263044942/">Flickr</a>.</p>

<p><a href="http://www.flickr.com/photos/whazzmaster/7869056820/"><img class="right" src="http://farm9.staticflickr.com/8282/7869056820_aacfe79e4b_n.jpg" width="320" height="213" title="Greg Tarnoff at Madison Ruby 2012" ></a></p>

<p>I&rsquo;m working off the conference hangover. Email catchup, priotizing
tasks, etc. took up my time this morning, but I couldn&rsquo;t let Madison&rsquo;s
premier software conference fade without writing down some thoughts.</p>

<p>Firstly: much love to Jim and Jen Remsik as well as all the volunteers,
speakers, and organizers that helped make v2 of Madison Ruby even more
fun and entertaining than the inaugural conf last year. The diversity
of topics was again front and center: from team
dynamics, to talks about social justice, to funky drummers, to sources
of inspiration and the finer points of immigration law, the organizers
found a way to communicate technical content while advancing the
community in other areas as well.</p>

<p>First up was the <a href="http://madisonruby2012.sched.org/event/45828a0ad9ccd45642acbeeefabd9aa1">Design Eye for the Dev Guy or Gal</a> workshop on Thursday.  I misunderstood the focus, which is mostly because I signed up for it before a comprehensive description had been published.  <a href="https://twitter.com/pengwynn">Wynn Netherland</a> did a great job laying out the finer points of HTML5, Sass, Compass, and more.  I had expected the workshop to range more towards the philosophy of web design, rather than a technical how-to around using the tools.  Even so, however, I learned a lot about Compass.  My previous aversion stemmed from when compass and blueprint were sold as a boxed set, but I&rsquo;m definitely going to check it out on the next major project.</p>

<p>Highlight: In a discussion about the ubiquity of Twitter Bootstrap Wynn
asked how many folks were using Octopress for their dev blog, and then
added, &ldquo;You know, you don&rsquo;t HAVE to use the default style&hellip; you can add
some color in there.&rdquo; <em>sheepish grin</em></p>

<p>I may have had a little too much fun at the Github-sponsored drinkup on
Thursday evening; waking up and riding my bike downtown at 7am was a
monumental task.</p>

<p>Friday&rsquo;s talks were very interesting, especially the <a href="http://madisonruby2012.sched.org/event/b50ba5ffa1585b870253b928b153d74f"><strong>Anti-Opression 101</strong></a>
talk by Lindsey Bieda and Steve Klabnik.  Though I had seen it a
previous <a href="http://www.meetup.com/Mad-Railers/">Mad-Railers meetup</a> I also enjoyed <a href="https://twitter.com/rathboma">Matthew Rathbone</a>&rsquo;s talk
about how <a href="http://foursquare.com">Foursquare</a> uses <a href="http://hadoop.apache.org/">Hadoop</a> for its various data processing needs. Unfortunately, I had to take off early on Friday and missed some of the afternoon talks, including what I heard was a <a href="https://twitter.com/#!/search/?q=clyde+%23madisonruby&amp;src=typd">fantastic 45 minutes</a> with <a href="http://en.wikipedia.org/wiki/Clyde_Stubblefield">Clyde Stubblefield</a>.</p>

<p>Saturday I was feeling a lot better, and hit the Farmer&rsquo;s Market early
for coffee and pastries.  I&rsquo;m embarassed to say that I hadn&rsquo;t looked
at the schedule closely enough and so it was an extremely pleasant surprise
that the first talk was by Paolo Perrotta,  author of the best Ruby book
in existence: <a href="http://pragprog.com/book/ppmetr/metaprogramming-ruby">Metaprogramming Ruby</a>.
It was a great talk about ghosts, fake ghosts, and all manner of
potential problems one will encounter when using the metaprogramming
aspect of the Ruby language.</p>

<p>Later in the day were several successive talks that excited the hell out
of me, but none moreso than <a href="https://twitter.com/rubybuddha">Leon Gersing</a>&rsquo;s talk
on the Weird in programming.  Difficult to describe so I&rsquo;ll just say
that if he&rsquo;s speaking at a conference make sure you get your ass to that
talk and be prepared to enjoy it.</p>

<p>The <strong>Teaching Rails</strong> panel discussion late in the day on Saturday was
interesting.  I almost didn&rsquo;t attend because I thought it was going to
be about how best to teach Rails to new folks.  Instead it was more
about the <em>business</em> of teaching Rails and how each of the four
panelists approached it.  Ultimately the panel dovetailed into a talk
about certification, payscales, and other highly interesting topics to
any software developer.  I felt that <a href="https://twitter.com/j3">Jeff Casimir</a>&rsquo;s innocent
suggestion of some kind of certification was not considered for a single
second before being shouted down by everyone else on the panel and in
attendance.  In particular, I think his idea has merit but the operational reality is
bad, which is why everyone just said &ldquo;NO CERTIFICATION&rdquo; when I think
what is needed is a
discussion about what certification is trying to accomplish and how it
can be done without turning into a paradise for grifters and dummies.</p>

<p>This was just a taste of the goings-on at Madison Ruby 2012. Others will
likely have a fuller rundown of the events so I just hit what were, to
me, the highlights.  If you&rsquo;re down on the Ruby tip I highly suggest you
try to get to Madison for next year&rsquo;s conference.  You can already hit
the <a href="http://2013.madisonruby.org/">Very Early Bird registration page</a> and get a ticket for the low,
low price of $199.  Do it, and come hang out with me next year!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[I Have an Idea]]></title>
    <link href="http://whazzing.com/blog/2012/08/19/i-have-an-idea/"/>
    <updated>2012-08-19T22:14:00-05:00</updated>
    <id>http://whazzing.com/blog/2012/08/19/i-have-an-idea</id>
    <content type="html"><![CDATA[<p>Once upon a time I was in Vegas with some friends. Over the course of 72
hours myself and half a dozen friends drifted in and out of our hotel
room at different times of the day and night as we gambled and boozed
our way across the landscape.</p>

<p>At around 3am one friend drunkenly burst into the hotel room and started
going on and on about how great he was doing, gambling-wise.  He talked
at length even as it became obvious that he was winding down like some
kind of strange children&rsquo;s toy.  Then he surged out of bed and said, &ldquo;I
have an idea!&rdquo;  Another friend asked what it was and got the classic
response, &ldquo;I&rsquo;ll need $300 of your money.&rdquo;</p>

<p>&ldquo;And then what?&rdquo; asked the friend, genuinely intrigued.</p>

<p>Alas, friend one was already passed out.  When asked the next morning
what the great $300 was he had no idea what we were talking about.</p>

<p>I think about this story every time I see a vaguely defined,
ill-conceived <a href="http://www.kickstarter.com">Kickstarter campaign</a> that
will ultimately result in a fugue state where everyone wonders what
happened to their money in the morning.</p>

<p>(Note: this is not a jab at Kickstarter itself; I think there&rsquo;s some
great stuff going on there.)</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Becoming the Finisher]]></title>
    <link href="http://whazzing.com/blog/2012/03/20/becoming-the-finisher/"/>
    <updated>2012-03-20T09:13:00-05:00</updated>
    <id>http://whazzing.com/blog/2012/03/20/becoming-the-finisher</id>
    <content type="html"><![CDATA[<p>Via <a href="http://news.ycombinator.com/item?id=3728664">Hacker News</a> this morning I read Jacques Mattheij&rsquo;s <a href="http://jacquesmattheij.com/The+Starter+the+Architect+the+Debugger+and+the+Finisher">The Starter, the Architect, the Debugger and the Finisher</a>.  It was a great topic and one that I think about often; for me personally <strong>finishing projects smoothly is my biggest challenge</strong>.</p>

<p>For me, starting projects is a great time to be alive.  I love bootstrapping repeatable builds, testing systems, automatic doc generation, etc.  It&rsquo;s a reflexive response having seen so many projects that were doomed from the word &lsquo;go&rsquo; by developers who named folders any old thing.  Even folks that joined the team within the first year were confused as to where code was located and what (if any) naming conventions existed.</p>

<p>Similarly, I&rsquo;ve been writing software for millions of users for ten years now and these days I think intensely about architecture when bootstrapping new components or applications.  Making the appropriate trade-offs between short- and long-term design up front will accelerate development while leaving you open to pivoting or scaling when the time is right.</p>

<p>My problem comes to the final touches of a release.  For example, often when I&rsquo;m working on a new release of <a href="https://github.com/whazzmaster/fitgem">fitgem</a> I code up the functionality, write new tests, write inline API documentation as I create new methods, etc.  After I think I&rsquo;m done I&rsquo;ll take the library for a spin in <a href="http://pry.github.com">Pry</a> and start coding against the new API functions.  Things will go well for awhile and then I&rsquo;ll hit a snag where I forgot a parameter or had a typo in the code.  Great! My ad-hoc testing revealed something I hadn&rsquo;t included in the unit tests. <strong>AND THEN I RELEASE</strong>.  This is not a good thing, but I often spaz out when I get 95% of the way to finishing, hit a snag, and then fix my issue.  I guess I feel exasperated about how long this thing is taking and then just wig out and push it (WE&rsquo;LL DO IT LIVE!)</p>

<p>To be a good finisher I need to slow down and restart my release process (as light as it is!) when I hit problems.  I need to suppress the anxiousness when I hit minor problems before pushing live, go back to the top of my checklist, and start it over.  Doing that on small projects like a gem will instill good mental resistance to spazzing for large, important releases.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Don't Call Me an Engineer]]></title>
    <link href="http://whazzing.com/blog/2012/03/18/dont-call-me-an-engineer/"/>
    <updated>2012-03-18T11:13:00-05:00</updated>
    <id>http://whazzing.com/blog/2012/03/18/dont-call-me-an-engineer</id>
    <content type="html"><![CDATA[<p>When I go <a href="http://www.wisc.edu">on campus</a> to do university recruiting, or I&rsquo;m in a non-technical social situation where I must explain what I do for a living, I often take great pains to explain what should be a simple thing.  My title in my company is &ldquo;Senior Software Engineer&rdquo; but I always very precisely call myself a &ldquo;software developer,&rdquo; &ldquo;programmer,&rdquo; or &ldquo;software nerd.&rdquo;</p>

<p>I am uncomfortable specifically with the &ldquo;engineer&rdquo; label, and that discomfort stems primarily from a panel discussion I attended in conjunction with the <a href="https://ecs.engr.wisc.edu/public/index.php">UW Engineering Career Services</a> group.</p>

<p>For some background, at the University of Wisconsin-Madison, Computer Science is <em>not</em> part of the School of Engineering, but a department in the School of Letters &amp; Science.  Even so, Computer Science students are given leave to particpate in School of Engineering career fairs and recruiting due to the crossover technical skillset.</p>

<p>As someone who conducts on-campus interviews and attends career fairs for my company at UW I was invited to a panel discussion on &ldquo;starting your first engineering job after graduating.&rdquo;  It was a fantastic topic for a panel because many seniors are so busy interviewing, wrapping up courses, and thinking about relocation concerns that they often don&rsquo;t think much about the actual beginning of a professional career.  Other folks on the panel included chemical engineers, industrial engineers, civil engineers, mechanical engineers and more.</p>

<p>Topics ranged across the board (Do you work a lot of hours? Do you like your boss? Have you been promoted yet?) but one that stuck with me was the question: &ldquo;Should I pay/study for my engineer certification? Is it better to do it before interviewing or will my employer fund the cost?&rdquo;  Many engineers on the panel had various opinions and it really did vary widely by field, but when it got to me I just shrugged and told the truth: <strong>there is no professional certification to be a software &ldquo;engineer&rdquo;</strong>.  There are certainly certifications for working with a particular software system, but there is no certification that will allow you to be insured against writing buggy software.<sup id='fnref:1'><a href='#fn:1' rel='footnote'>1</a></sup></p>

<p>I admire engineers and really only want to drive on bridges and use power tools that were designed by professional engineers.  Software developers
CAN produce incredible feats of redundant, bug-free software system design and implementation but with the stipulation that time and process are needed to accomplish such things.  There likely do exist folks with the sufficient experience and knowledge to be called software engineers, but I am not one of them and they are few and far between.</p>

<p>In the tech sphere this is really more of an academic conversation- we all speak the same language.  Everyone at your software company has some flavor of &ldquo;engineer&rdquo; in their title, and no one thinks twice about it.  When thrust into the larger world of engineers, however, the loosey-goosey nature of software development and it&rsquo;s similarity to more of a craft than a discipline make strict adherance to standards of proven technical excellence difficult.</p>

<p>What do you think? Does the typical professional software development environment make you think of &ldquo;engineering&rdquo; in the same way that mechanical or civil engineers practice it?  Does the fact that we do TDD/BDD make up for the fact that software tends not to have perfectly understood natural laws it must follow?</p>

<div class="footnotes">
    <ol>
        <li id='fn:1'>This argument has indeed been made <a href="http://www.google.com/search?q=software+development+is+not+engineering">many times before</a>; this post is more my feelings about it. <a href='#fnref:1' rev='footnote'>↩</a></li>
    </ol>
</div>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Whazzing.com Moved to Github]]></title>
    <link href="http://whazzing.com/blog/2012/03/17/whazzing-dot-com-moved-to-github/"/>
    <updated>2012-03-17T23:09:00-05:00</updated>
    <id>http://whazzing.com/blog/2012/03/17/whazzing-dot-com-moved-to-github</id>
    <content type="html"><![CDATA[<p>Two things forced my hand to move my development blog off of my own Rails-based blogging codebase and onto
<a href="http://pages.github.com/">Github Pages</a> via <a href="http://octopress.org/">Octopress</a>:</p>

<ol>
<li>My VPS is becoming severely overcrowded with deployed apps; I use it as a testbed for a lot of ideas as well as my <a href="http://www.whazzmaster.com">main swearing-at-pop-culture blog</a> and I didn&rsquo;t want to host yet another heavyweight rails app to chew through limited resources.</li>
<li>I reaaally like the &lsquo;one-file-per-post&rsquo; model of Octopress/Jekyll, and keeping my development blog/presentations right next to my open source code is very appealing.</li>
</ol>


<p>Since I wrote my latest blog engine to take markdown input it was easy-as-pie to export the existing posts to files and then use them to bootstrap this Octopress site.  For now I&rsquo;ll ride on the default theme and see how it goes.  I hope to spend more time iterating on my presentations and a bunch of C++ code that I&rsquo;m working on for a work project, so it&rsquo;s also a plus that I don&rsquo;t have maintain the platform source tree anymore.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Fitgem v0.5.0]]></title>
    <link href="http://whazzing.com/blog/2012/01/22/fitgem-v0-5-0/"/>
    <updated>2012-01-22T00:00:00-06:00</updated>
    <id>http://whazzing.com/blog/2012/01/22/fitgem-v0-5-0</id>
    <content type="html"><![CDATA[<p>I&rsquo;m happy to announce that the <a href="http://groups.google.com/group/fitbit-api/browse_thread/thread/8e8aed16706642d6#">latest Fitbit API features</a> have been exposed through the fitgem ruby library and released as v0.5.0.</p>

<p>New features include glucose, blood pressure, and heart rate logging and retrieval methods.   Documentation has also been updated to include new endpoints for the Time Series interface.</p>

<p><a href="https://github.com/whazzmaster/fitgem">Source</a> | <a href="http://rubygems.org/gems/fitgem">Gem</a> | <a href="https://github.com/whazzmaster/fitgem/issues">Issues</a> | <a href="http://rubydoc.info/github/whazzmaster/fitgem/master/frames">Documentation</a></p>

<h3>v0.5.0 changelog</h3>

<ul>
<li>Added <tt>Fitgem::Client#heart_rate_on_date</tt> to retrieve heart rate data by date</li>
<li>Added <tt>Fitgem::Client#log_heart_rate</tt> to log heart rate data</li>
<li>Added <tt>Fitgem::Client#delete_heart_rate_log</tt> to delete previously logged heart rate data</li>
<li>Added <tt>Fitgem::Client#blood_pressure_on_date</tt> to retrieve blood pressure data by date</li>
<li>Added <tt>Fitgem::Client#log_blood_pressure</tt> to log blood pressure data</li>
<li>Added <tt>Fitgem::Client#delete_blood_pressure_log</tt> to delete previously logged blood pressure data</li>
<li>Added <tt>Fitgem::Client#glucose_on_date</tt> to retrieve glucose data by date</li>
<li>Added <tt>Fitgem::Client#log_glucose</tt> to log glucose data</li>
<li>Added <tt>Fitgem::Client#delete_glucose_log</tt> to delete previously logged glucose data</li>
<li>Updated README</li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Long Live Markdown]]></title>
    <link href="http://whazzing.com/blog/2011/12/08/long-live-markdown/"/>
    <updated>2011-12-08T00:00:00-06:00</updated>
    <id>http://whazzing.com/blog/2011/12/08/long-live-markdown</id>
    <content type="html"><![CDATA[<p>I&rsquo;ve been doing a lot of development around <a href="http://daringfireball.net/projects/markdown/syntax">markdown</a> lately and I&rsquo;m really starting to love it.  Specifically, <a href="http://github.github.com/github-flavored-markdown/">Github-flavored markdown</a> has grown on me with its ability to do easy fenced code blocks and syntax highlighting.</p>

<pre><code>```ruby
comments = Comment.all
```
</code></pre>

<p>becomes</p>

<pre lang="ruby">
comments = Comment.all
</pre>


<p>When I rewrote the code for this web site awhile back I decided to support markdown, but didn&rsquo;t really think I&rsquo;d use it much; maybe to do code blocks but not much else.  Now I find myself writing markdown for all content, and only translating it through various interpreters when I need the HTML.  In retrospect I&rsquo;m extremely glad I went through the effort to add markdown support for the site&mdash; I use it all the time now.</p>

<p>There&rsquo;s an <strong>incredible</strong> app for writing markdown on the fly: <a href="http://mouapp.com/">Mou</a> is a Mac application that lets you input markdown on the left pane and the HTML is dynamically updated in the right pane.  I&rsquo;m literally using it right now to write this post, just to get a preview of what it will look like when I drop it into the &lt;textarea&gt; on the web site.</p>

<p>I basically use it for all markdown content authoring, and then I copy/paste the result into whatever application/content field I will use it in.  It allows me to do edit/revision cycles on content as well as seeing the application of styles.  Highest recommendation.</p>

<p>I also recently forked <a href="https://github.com/sr/git-wiki">git-wiki</a> and started working on improving it for my own use.  It also uses Markdown to write the wiki entries, which gets a little weird if you&rsquo;ve ever used <a href="http://www.mediawiki.org/wiki/MediaWiki">MediaWiki</a> or <a href="http://www.wikipedia.com">Wikipedia</a>.  The default way to define <a href="http://twiki.org/cgi-bin/view/TWiki/WikiWord">wikiwords</a> in git-wiki didn&rsquo;t really work for me so I updated it and checked everything back into <a href="https://github.com/whazzmaster/git-wiki">my own repo</a>.  I&rsquo;ll be updating more about my git-wiki fork once I get it refactored and a little more configurable.</p>

<p>So there you go- markdown is awesome and you should write your content in it; if you&rsquo;ve never worked with it then try it out on Github (just make a public repo and create a README.md in the index).</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Fitgem v0.4.0]]></title>
    <link href="http://whazzing.com/blog/2011/12/02/fitgem-v0-4-0/"/>
    <updated>2011-12-02T00:00:00-06:00</updated>
    <id>http://whazzing.com/blog/2011/12/02/fitgem-v0-4-0</id>
    <content type="html"><![CDATA[<p>I&rsquo;m happy to announce that the <a href="http://groups.google.com/group/fitbit-api/browse_thread/thread/3144a7299b60fa16">latest Fitbit API features</a> have been exposed through the fitgem ruby library and released as v0.4.0.</p>

<p>In addition to the new features, I thoroughly documented the entire library API (<a href="http://rubydoc.info/github/whazzmaster/fitgem/master/frames">available here</a>), added many more unit tests, refactored the subscriptions methods, and moved the oauth process documentation to the <a href="https://github.com/whazzmaster/fitgem/wiki/The-OAuth-Process">project wiki on github</a>.</p>

<p><a href="https://github.com/whazzmaster/fitgem">Source</a> | <a href="http://rubygems.org/gems/fitgem">Gem</a> | <a href="https://github.com/whazzmaster/fitgem/issues">Issues</a> | <a href="http://rubydoc.info/github/whazzmaster/fitgem/master/frames">Documentation</a></p>

<h3>v0.4.0 changelog</h3>

<ul>
<li>Added YARD documentation to thoroughly document code</li>
<li>DEPRECATED: <tt>Fitgem::Client#log_weight</tt> method, use <tt>Fitgem::Client#log_body_measurements</tt> instead.<br/>
The new method allows you to log more than weight (bicep size, body fat %, etc.)</li>
<li>Added <tt>Fitgem::FoodFormType</tt> to be used in calls to <tt>Fitgem::Client#create_food</tt></li>
<li>Added <tt>Fitgem::Client#log_sleep</tt> to log sleep data to fitbit</li>
<li>Added <tt>Fitgem::Client#delete_sleep_log</tt> to delete previously logged sleep data</li>
<li>Added <tt>Fitgem::Client#activities</tt> method to get a list of all activities</li>
<li>Added <tt>Fitgem::Client#activity_statistics</tt> method to get statistics for all logged activities</li>
<li>Added to documentation of supported endpoints for <tt>Fitgem::Client#data_by_time_range</tt></li>
<li>Added unit tests for parameter validation for many methods</li>
<li>Overhauled notifications methods, including extensive documentation,
unit tests, refactoring, and a couple of bug fixes.  These methods now
return both the HTTP status code and the JSON response body.  See <a href="https://wiki.fitbit.com/display/API/Subscriptions-API">https://wiki.fitbit.com/display/API/Subscriptions-API</a>
for information on how to interpret each of the error codes.</li>
<li>Added fitgem to travis-ci for continuous integration (<a href="http://travis-ci.org/#!/whazzmaster/fitgem">http://travis-ci.org/#!/whazzmaster/fitgem</a>)</li>
<li>Added fitgem to rubydoc.info (<a href="http://rubydoc.info/github/whazzmaster/fitgem/master/frames">http://rubydoc.info/github/whazzmaster/fitgem/master/frames</a>)</li>
<li>Updated README</li>
<li>Moved OAuth documentation from the README to the <a href="https://github.com/whazzmaster/fitgem/wiki/The-OAuth-Process">fitgem wiki</a></li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[December 2011 Reading List]]></title>
    <link href="http://whazzing.com/blog/2011/12/02/december-2011-reading-list/"/>
    <updated>2011-12-02T00:00:00-06:00</updated>
    <id>http://whazzing.com/blog/2011/12/02/december-2011-reading-list</id>
    <content type="html"><![CDATA[<p>I thought I&rsquo;d jot down my current technical reading list.  I tend not to read technical books straight through, but instead I pick up a few at a time and refresh myself on whatever I&rsquo;m interested in at the time.  (Full disclosure: these links include my Amazon affiliate code).</p>

<ul>
<li><a href="http://www.amazon.com/gp/product/0596008643/ref=as_li_qf_sp_asin_tl?ie=UTF8&amp;tag=whazzingcom-20&amp;linkCode=as2&amp;camp=1789&amp;creative=9325&amp;creativeASIN=0596008643">Learning Mysql</a><p>Back in 2002 I got my exposure to SQL while doing elemntary PHP programming.  I read a little about MySQL back then, but never really went deep into things such as indexes and optimizations.  Rails obscures a lot of that stuff, but I wanted to be able to optimize efficiently and learn more about the underlying technology. So far this book has been really good at diving down underneath your SELECT, UPDATE, CREATE, and DROP actions.</p></li>
<li><a href="http://www.amazon.com/gp/product/1934356476/ref=as_li_tf_tl?ie=UTF8&amp;tag=whazzingcom-20&amp;linkCode=as2&amp;camp=1789&amp;creative=9325&amp;creativeASIN=1934356476">Metaprogramming Ruby</a> <p>This is bar none my favorite Ruby book, and in my opinion is far better than the Pickaxe book for those who are coming to Ruby from another language/ecosystem.  The fellas at <a href="http://www.bendyworks.com">Bendyworks</a> have been doing a bi-weekly book club on this book and I&rsquo;ve happily attended as many as I could to talk about it.  This book goes into incredible, understandable detail about the object model and dynamic nature of programming in Ruby.  It gets my highest recommendation.</p></li>
<li><a href="http://www.amazon.com/gp/product/0393979504/ref=as_li_tf_tl?ie=UTF8&amp;tag=whazzingcom-20&amp;linkCode=as2&amp;camp=1789&amp;creative=9325&amp;creativeASIN=0393979504">C Programming: A Modern Approach</a> <p>My college computer science curriculum was in C++ and Java.  My job at <a href="http://www.intuit.com">Intuit</a> involves C/C++/C# development, but it tends to fall heavily into the C++/C# side of things.  I respect the hell out of Zed Shaw&rsquo;s outlook on programming, and truly believe that a working knowledge of C development will take you far.  To that end, I&rsquo;ve been working through <a href="http://c.learncodethehardway.org/">Learn C the Hard Way</a> online while reading this superb book.  I also purchased the original <a href="http://www.amazon.com/gp/product/0131103628/ref=as_li_tf_tl?ie=UTF8&amp;tag=whazzingcom-20&amp;linkCode=as2&amp;camp=1789&amp;creative=9325&amp;creativeASIN=0131103628">The C Programming Language</a> book, but A Modern Approach is, in my opinion, superior as a reference and primer.</p></li>
</ul>


<p>My technical reading list changes often; I&rsquo;ll usually read through three books over the course of several weeks and then pull more off my shelf and refresh myself on a different topic.  It&rsquo;s why I also buy books on the periphery of my interests just to have them on my shelf.  I enjoy having the references available, even if I don&rsquo;t read them as soon as they arrive.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Whazzing.com v1.2]]></title>
    <link href="http://whazzing.com/blog/2011/10/25/whazzing-com-v1-2/"/>
    <updated>2011-10-25T00:00:00-05:00</updated>
    <id>http://whazzing.com/blog/2011/10/25/whazzing-com-v1-2</id>
    <content type="html"><![CDATA[<p>Whazzing.com v1.2 has been deployed to production.  Updates include:</p>

<ul>
<li>Posts can now be attached to projects in order to create news feeds on a per-project basis.</li>
<li>Added favicon to the site</li>
<li>Added ranking implementation for posts using <a href="http://redis.io/">Redis</a>.  Not in use yet.</li>
<li>Added RSS feed for posts.  Available at <a href="http://www.whazzing.com/posts.rss">http://www.whazzing.com/posts.rss</a></li>
<li>Updated styles for the post and project pages</li>
</ul>


<p>Upcoming plans include:</p>

<ul>
<li>Post ranking implemented</li>
<li>Section on the homepage for ranked posts</li>
<li>Project RSS feeds</li>
<li>Twitter integration on projects</li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Fitgem v0.3.6]]></title>
    <link href="http://whazzing.com/blog/2011/10/25/fitgem-v0-3-6/"/>
    <updated>2011-10-25T00:00:00-05:00</updated>
    <id>http://whazzing.com/blog/2011/10/25/fitgem-v0-3-6</id>
    <content type="html"><![CDATA[<p>On October 14th Fitbit <a href="http://groups.google.com/group/fitbit-api/msg/069c80e969cf603e">announced the latest version of their API</a>, including support for features of their new Fitbit Ultra tracker hardware.</p>

<p><a href="https://github.com/whazzmaster/fitgem">Source</a> | <a href="http://rubygems.org/gems/fitgem">Gem</a> | <a href="https://github.com/whazzmaster/fitgem/issues">Issues</a> | <a href="http://rubydoc.info/github/whazzmaster/fitgem/master/frames">Documentation</a></p>

<h1>Updates</h1>

<h3>Floors and elevation info from <code>activities_on_date</code></h3>

<pre lang="ruby">
pp client.activities_on_date("2011-10-24")
</pre>




<pre lang="javascript">
{"activities"=>
  [{"activityId"=>2130,
    "activityParentId"=>2130,
    "activityParentName"=>
     "Weight lifting (free, nautilus or universal-type), light or moderate effort, light workout, general",
    "calories"=>228,
    "description"=>"",
    "duration"=>3600000,
    "hasStartTime"=>true,
    "isFavorite"=>true,
    "logId"=>2136964,
    "name"=>
     "Weight lifting (free, nautilus or universal-type), light or moderate effort, light workout, general",
    "startTime"=>"16:15"}],
 "goals"=>
  {"activeScore"=>1000,
   "caloriesOut"=>2911,
   "distance"=>5,
   "floors"=>10,
   "steps"=>10000},
 "summary"=>
  {"activeScore"=>495,
   "activityCalories"=>927,
   "caloriesOut"=>2458,
   "distances"=>
    [{"activity"=>"total", "distance"=>2.07},
     {"activity"=>"tracker", "distance"=>2.07},
     {"activity"=>"loggedActivities", "distance"=>0},
     {"activity"=>"veryActive", "distance"=>0.3},
     {"activity"=>"moderatelyActive", "distance"=>0.68},
     {"activity"=>"lightlyActive", "distance"=>1.09},
     {"activity"=>"sedentaryActive", "distance"=>0},
     {"activity"=>
       "Weight lifting (free, nautilus or universal-type), light or moderate effort, light workout, general",
      "distance"=>0}],
   "elevation"=>90,
   "fairlyActiveMinutes"=>118,
   "floors"=>9,
   "lightlyActiveMinutes"=>102,
   "marginalCalories"=>562,
   "sedentaryMinutes"=>1210,
   "steps"=>4590,
   "veryActiveMinutes"=>10}
}
</pre>


<h3>Floors and elevation info from <code>data_by_time_range</code></h3>

<pre lang="ruby">
pp client.data_by_time_range("/activities/log/floors", {:base_date => "2011-10-24", :period => "1d"})
</pre>




<pre lang="javascript">
{"activities-log-floors"=>[{"dateTime"=>"2011-10-24", "value"=>"9"}]}
</pre>


<h3>Food Goals now available through the <code>foods_on_date</code> method</h3>

<pre lang="ruby">
pp client.foods_on_date("2011-10-24")
</pre>




<pre lang="javascript">
{"foods"=>[],
 "goals"=>{"calories"=>2911},
 "summary"=>
  {"calories"=>0,
   "carbs"=>0,
   "fat"=>0,
   "fiber"=>0,
   "protein"=>0,
   "sodium"=>0,
   "water"=>0}
}
</pre>


<h3>Device info now returns lastSyncTime</h3>

<pre lang="ruby">
pp client.devices
</pre>




<pre lang="javascript">
[{"battery"=>"Full",
  "id"=>*****,
  "lastSyncTime"=>"2011-10-25T09:54:40.000",
  "type"=>"TRACKER"}]
</pre>


<h3>Get details on a food with new method <code>food_info</code></h3>

<p>There is a new method that will fetch detailed food information given a food ID.  Food IDs are generally retrieved by searching for a food using <code>find_food</code>.</p>

<pre lang="ruby">
# Get food info for an apple
pp client.food_info 20711
</pre>




<pre lang="javascript">
{"food"=>
  {"accessLevel"=>"PUBLIC",
   "brand"=>"Shoney's",
   "calories"=>81,
   "defaultServingSize"=>5,
   "defaultUnit"=>{"id"=>226, "name"=>"oz", "plural"=>"oz"},
   "foodId"=>20711,
   "name"=>"Apple",
   "units"=>[226, 180, 147, 389]}
}
</pre>


<h3>Calories now returned in <code>find_food</code> results</h3>

<pre lang="ruby">
pp client.find_food("GoLean Raisin Bran Crunch Cereal")
</pre>




<pre lang="javascript">
{"foods"=>
  [{"accessLevel"=>"PUBLIC",
    "brand"=>"Kellogg's",
    "calories"=>110,
    "defaultServingSize"=>1,
    "defaultUnit"=>{"id"=>17, "name"=>"bar", "plural"=>"bars"},
    "foodId"=>20942,
    "name"=>"Cereal Bar, Raisin Bran Crunch",
    "units"=>[17]},
   {"accessLevel"=>"PUBLIC",
    "brand"=>"Safeway",
    "calories"=>230,
    "defaultServingSize"=>1,
    "defaultUnit"=>{"id"=>304, "name"=>"serving", "plural"=>"servings"},
    "foodId"=>79051,
    "name"=>"Raisin Bran Crunch Cereal",
    "units"=>[304, 91, 256, 279]}]
}
</pre>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Searching vs Finding]]></title>
    <link href="http://whazzing.com/blog/2011/09/26/searching-vs-finding/"/>
    <updated>2011-09-26T00:00:00-05:00</updated>
    <id>http://whazzing.com/blog/2011/09/26/searching-vs-finding</id>
    <content type="html"><![CDATA[<p>I&rsquo;ve found that many of the truly interesting and outlook-altering pieces of information I&rsquo;ve acquired have come via finding something randomly or pseudo-randomly as opposed to searching it out.</p>

<p>These days the information in question is often a tool, configuration, or piece of code that radically shortcuts an oft-repeated activity.  It has nothing to with luck, or ability to use Google, however.  <strong>The delight in finding the perfect tool or option is often that you never conceived that it could exist in the first place</strong>.</p>

<p>The most stark example I&rsquo;ve had recently is in pursuit of my quest to <a href="http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/">learn vim</a>.  In changing over from TextMate to vim many times I would end up pondering really newb questions: how do I cut a line of text? How do I move to the end of a file?  A couple of HI-YAH&rsquo;s of Google-Fu later I&rsquo;ve got the answer an I&rsquo;m trucking along.  Some days, however, I&rsquo;ll be reading something unrelated and all of a sudden learn that <strong>dt followed by a character</strong> <em>will delete from the cursor position to the next instance of that character</em>.  It&rsquo;s weird, but that was a game-changer for me.  Changing out strings became: <strong>dt&#8221;</strong> and then insert and go.</p>

<p>I could also characterize my use of <a href="https://github.com/guard/guard">guard</a> in this way.  I was at a <a href="http://www.meetup.com/Mad-Railers/">Mad-Railers</a> hack day awhile back and <a href="http://twitter.com/#!/listrophy">Brad</a> happened to be using <a href="https://github.com/guard/guard-rspec">guard for his rspec execution</a> during TDD.  It was a revelation that I could just edit files and tests and it would automatically rerun.  Here&rsquo;s where things get interesting, however.  It had previously never occurred to me to even look for a way to speed up my tests or optimize the time spent manually executing them.  It was a problem I didn&rsquo;t know I had.  After learning about guard I looked through <a href="https://github.com/guard/guard/wiki/List-of-available-Guards">the list of available guards</a>, however, and found some other interesting ones.  These additional plugins for the guard model were also solving problems I didn&rsquo;t even know were bugging me until I found they were solved problems.</p>

<p>This all came to me this morning as I was watching Ryan Bates&#8217; <a href="http://railscasts.com/episodes/285-spork">Railscast on using Spork</a> to speed up test execution further by preloading the Rails framework and keeping it in memory between tests.</p>

<p>When worrying about getting a primary goal completed (say, a feature in an application) you don&rsquo;t often think about solutions to one-off problems or annoyances, let alone prioritize solving them.  This is partially why I invest time at the beginning of a project to develop and optimize the code-test-fix cycle, why I obsess over the deployment model when I only have a README, and why I like continuous integration before a test has been written.  Once your process for coding is solid, you can optimize it piecemeal as you <strong>need to</strong> or as you <strong>find unexpected tools or processes</strong> that would increase your productivity drastically.</p>

<p>An example: my tests were already running really well under guard, but 15 minutes or install and configuration of <a href="https://github.com/guard/guard-spork">guard-spork</a> I saw immediate speed gains.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Paperclip and ImageMagick on Ubuntu]]></title>
    <link href="http://whazzing.com/blog/2011/09/23/paperclip-and-imagemagick-on-ubuntu/"/>
    <updated>2011-09-23T00:00:00-05:00</updated>
    <id>http://whazzing.com/blog/2011/09/23/paperclip-and-imagemagick-on-ubuntu</id>
    <content type="html"><![CDATA[<p>In getting the <a href="https://github.com/thoughtbot/paperclip">paperclip gem</a> working on my server for some screenshots I ran into a frustrating problem.  I kept getting an error during model saving: <strong>&ldquo;/tmp/1234bduct-123.png is not recognized by the &lsquo;identify&rsquo; command&rdquo;</strong>.  Eventually I solved the problem, so here is my solution, hoping that it helps someone else out there.</p>

<p>After some googling and reading <a href="http://www.stackoverflow.com">Stack Overflow</a> I quickly came across the solution that Paperclips :command_path option wasn&rsquo;t being set correctly.  The problem, however, was that it looked like I was correctly setting the ImageMagick path:</p>

<pre lang="bash">
$ which identify
/usr/local/bin/identify
</pre>


<p>I kept double- and triple-checking that the option was set correctly in my config/environments/staging.rb file:</p>

<pre lang="ruby">
WhazzingCom::Application.configure do
  ....
  Paperclip.options[:command_path] = "/usr/local/bin"
end
</pre>


<p>That seemed to be correct, but I still kept getting the same error.  Eventually I came across an <a href="http://blog.e-thang.net/2009/12/30/paperclipimagemagickrmagick-error-is-not-recognized-by-the-identify-command/comment-page-1/#comment-1067">excellent suggestion</a> that perhaps my installed version of ImageMagick was incomplete, corrupt, or missing libs or dependencies.  First I reran the ImageMagick apt-get install&hellip;</p>

<pre lang="bash">
$ sudo apt-get install imagemagick --fix-missing
</pre>


<p>&hellip;which installed identify to <strong>/usr/bin</strong> rather than the existing version in <strong>/usr/local/bin</strong>.  I then updated my environment file to the following&hellip;</p>

<pre lang="ruby">
WhazzingCom::Application.configure do
  ....
  Paperclip.options[:command_path] = "/usr/bin"
end
</pre>


<p>&hellip;and refreshed the page and everthing worked as expected!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Redesigning Whazzing.com]]></title>
    <link href="http://whazzing.com/blog/2011/09/21/redesigning-whazzing-com/"/>
    <updated>2011-09-21T00:00:00-05:00</updated>
    <id>http://whazzing.com/blog/2011/09/21/redesigning-whazzing-com</id>
    <content type="html"><![CDATA[<p>For the last month I&rsquo;ve been working to create this new development-focused blog and project repository for my work.  I was previously self-hosting a <a href="http://www.wordpress.org">Wordpress</a> blog, but I&rsquo;ve developed a desire to own my destiny when it comes to the display of my work.  There were a ton of little features I wanted to develop but didn&rsquo;t really want to delve (back) into the PHP world or hack at the Wordpress template framework.</p>

<p>I&rsquo;d recently read the excellent <a href="http://www.abookapart.com/products/responsive-web-design">Responsive Web Design</a> and it made me very excited to design a site that effortlessly works on phones, tablets, monitors, and TVs.  Another project I have in mind is primarily aimed at mobile form factors, so I thought a semi-major experiment was in order to ensure I was thinking in the right direction when it came to media queries and mobile design.</p>

<h2>Technology</h2>

<p>I built <a href="http://whazzing.com">whazzing.com</a> with ruby 1.9.2, rails 3.1, mysql, and various gems.  My first commit was August 19th, 2011 and I deployed version 1.0 to production on September 20th, 2011.</p>

<p>As I started coding this site, Rails 3.1 was entering it&rsquo;s final release candidate testing phase so I decided to start fresh on it.  The asset pipeline is just a terrific addition to the framework, and combining it with the style organization I&rsquo;ve been developing off of Dale Sande&rsquo;s incredible <a href="http://axle.dalesande.com">Axle framework</a> provided for a <strong>very smooth visual design experience</strong>.  I added a little bit to Dale&rsquo;s CSS organization to support the media queries I wanted to support.</p>

<pre>
assets
|-- stylesheets
    |-- admin.css.scss
    |-- application.css.scss
    |-- design.css.scss
    |-- devices
    |    |-- phones.css.scss
    |    |-- tablets.css.scss
    |    |-- high-resolution.css.scss
    |-- imports
    |    |-- colors.css.scss
    |    |-- form.css.scss
    |    |-- mixins.css.scss
    |    |-- navigation.css.scss
    |    |-- text.css.scss
    |-- reset.css.scss
    |-- typography.css.scss
</pre>


<p>One of the interesting takeways from the excellent testing panel at <a href="http://madisonruby.org/schedule">Madison Ruby</a> was that people are divided about the usefulness of <a href="http://cukes.info/">cucumber</a>.  I had always stumbled in wrangling cucumber to be really useful for the applications I was writing and so I decided to eschew its usage this time. I focused instead on getting good coverage via my <a href="https://www.relishapp.com/rspec">RSpec</a> controller and model tests.  I found that leaving cucumber aside really streamlined the process and didn&rsquo;t leave me eternally feeling like I was losing focus on the functionality I wanted due to the the myriad tests that were demanded by all the tools I was using.</p>

<p>Madison Ruby was a fantastic source of information on how to write better ruby code and rails applications.  In particular, <a href="http://twitter.com/#!/j3">Jeff Casimir&rsquo;s</a> talk on using view-models and decorators as opposed to helpers in rails was food for thought.  Halfway through implementation on this site I switched over to using <a href="https://github.com/jcasimir/draper">draper</a> for my presentation logic and I <strong>love it</strong>.</p>

<p>Another tool I wanted to test out for this project was <a href="https://github.com/nvie/gitflow">git-flow</a>.  At <a href="http://scottchacon.com/">Scott Chacon&rsquo;s</a> eye-opening Git workshop I increased my git knowledge 10 times, easily.  Going through the underlying structures of git taught me a lot about what&rsquo;s really going on during commits, push, and branching, and I wanted to try to formalize the release process of this project a bit more using git-flow&rsquo;s branching model.  The result: I loved the structure of the branches, even if this was a one-man project, and will definitely use it on more projects in the future.</p>

<p>Finally, I&rsquo;ve been more and more intrigued by <a href="http://daringfireball.net/projects/markdown/syntax">Markdown</a> since Github and many other sites support it these days.  Instead of pouring time into creating a WYSIWYG editor or trying to drop one in, I instead grabbed the <a href="https://github.com/blog/832-rolling-out-the-redcarpet">Redcarpet</a> gem and simply use markdown to create the posts and project descriptions.  I also use <a href="https://github.com/github/albino">albino</a> and <a href="http://pygments.org/">pygments</a> for code highlighting.</p>

<h2>Methodology &amp; Features</h2>

<p>The problem I had to overcome this time (and every time I jumpstart a project) is that too often I get bogged down on tangents.  I&rsquo;ll get fixated on one unimportant feature or line of code, I&rsquo;ll get frustrated that I can&rsquo;t get it the way I want, and eventually I won&rsquo;t even want to open the text editor due to feelings of dread.  This time I was determined to mercilessly cut features until I had something simple I could get coded and deployed, and then iterate from there.  A few times I almost got bogged down, but forced myself to leave features on the table for future releases so that I could get my high priority functionality into production.</p>

<p>I settled on <strong>four</strong> main features for the first release:</p>

<ul>
<li><strong>Responsive design</strong> so that the site would look great on regular monitors, phones, and tablets.</li>
<li><strong>A micro-resume</strong> <a href="http://www.whazzing.com/me">viewable here</a> that I could link to from my new business cards and elsewhere</li>
<li><strong>Taggable blog posts</strong> without comments (for now)</li>
<li><strong>A project guide</strong> so that I can link to all my projects in one place, with links to docs and code where appropriate</li>
</ul>


<p>My major feature list for the next release includes:</p>

<ul>
<li><strong>Comments</strong> on blog posts (spam-protected and everything!)</li>
<li><strong>RSS feeds</strong> of blog posts</li>
<li><strong>Release tracking</strong> of projects</li>
<li><strong>Rating and ranking</strong> of blog posts</li>
</ul>


<p>I&rsquo;ll also, of course, be correcting anything that shakes out while using it.</p>

<h2>What&rsquo;s Next</h2>

<p>I&rsquo;m looking forward to extending this project, while using it as a platform to document the other things I&rsquo;m working on.  I would really like to use <a href="http://redis.io/">redis</a> for some analytics/tracking ideas I have, and I&rsquo;m interested in how to tie in <a href="http://akismet.com/">akismet</a> spam-blocking for comments.</p>

<p>The images along the left side don&rsquo;t scan well on mobile devices, so I&rsquo;m going to look into replacing them in the next release as well.  I like the structure of the site, but the specific details could be tightened a little.</p>

<p>I&rsquo;d like to get a styleguide up and running so that my CSS can be standardized a little.  I tried as much as possible to be OO in my CSS but failed in a few places that I&rsquo;d like to clean up.</p>

<h2>Thanks</h2>

<p>Many, many thanks to <a href="http://begriffsschrift.com/">Joe Nelson</a>, from whom I shamelessly stole the idea for the micro-resume.  Thanks so much for the idea- it jump-started what became the new site, blog, etc.</p>

<p>Also, thanks to <a href="http://kev.inburke.com/">Kevin Burke</a>. I read his blog post on <a href="http://kev.inburke.com/kevin/site-redesign/">designing your personal site</a> and was inspired to go beyond the usual &ldquo;reverse chronological order of posts&rdquo; home page.  Instead I tried to create a homepage that advertises all the things I&rsquo;m working on, blog posts being only one of the pieces.</p>

<p>Thanks to <a href="http://www.dalesande.com/">Dale Sande</a>, who helped me step up my CSS game with his excellent <a href="http://axle.dalesande.com">Axle framework</a> and thoughts on OOCSS (object-oriented CSS).  If you ever get a chance to attend his OOCSS talk definitely do it; as a primarily backend dude I found it immensely helpful for structuring my CSS and semantic markup.</p>
]]></content>
  </entry>
  
</feed>