<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>nickelcode</title>
	<atom:link href="http://nickelcode.com/feed/" rel="self" type="application/rss+xml" />
	<link>http://nickelcode.com</link>
	<description>penny for your thoughts, nickel for your code</description>
	<lastBuildDate>Sun, 10 Jan 2010 21:31:27 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.8.4</generator>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
			<item>
		<title>bebop: resource routing for Sinatra/Monk</title>
		<link>http://nickelcode.com/2010/01/10/bebop-resource-routing-for-sinatramonk/</link>
		<comments>http://nickelcode.com/2010/01/10/bebop-resource-routing-for-sinatramonk/#comments</comments>
		<pubDate>Sun, 10 Jan 2010 21:31:27 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[monk]]></category>
		<category><![CDATA[programming]]></category>
		<category><![CDATA[ruby]]></category>
		<category><![CDATA[sinatra]]></category>
		<category><![CDATA[webdev]]></category>
		<category><![CDATA[monkrb]]></category>
		<category><![CDATA[sinatrarb]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=715</guid>
		<description><![CDATA[Motivation
I&#8217;ve been using Monk with the armonk skeleton for the last couple of weeks to build a little app that monitors Craig&#8217;s List searches. Bebop aside, I&#8217;ve found it to be a really refreshing experience, but I knew when I started building the app that the vanilla routing DSL wasn&#8217;t going to meet my needs [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2010/01/10/bebop-resource-routing-for-sinatramonk/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Using a haskell dfa type to match strings</title>
		<link>http://nickelcode.com/2009/11/08/using-a-haskell-dfa-type-to-match-strings/</link>
		<comments>http://nickelcode.com/2009/11/08/using-a-haskell-dfa-type-to-match-strings/#comments</comments>
		<pubDate>Sun, 08 Nov 2009 22:15:28 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[uncategorized]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=661</guid>
		<description><![CDATA[A friend of mine recently covered deterministic and non-deterministic finite state machines (automata for the cool kids) in one of his classes and passed along a sample problem for me to figure out. Informally, build a dfa that will match a given string against another string in the provided alphabet. An example of this class [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/11/08/using-a-haskell-dfa-type-to-match-strings/feed/</wfw:commentRss>
		<slash:comments>5</slash:comments>
		</item>
		<item>
		<title>Ruby Cons</title>
		<link>http://nickelcode.com/2009/10/28/ruby-cons/</link>
		<comments>http://nickelcode.com/2009/10/28/ruby-cons/#comments</comments>
		<pubDate>Thu, 29 Oct 2009 03:55:27 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[uncategorized]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=640</guid>
		<description><![CDATA[I think technically this counts as an application of my readings from Algebra of Programming. Satisfied.

class Cons
  include Enumerable
  attr_accessor :child, :value

  def self.[](value, child=:empty)
    new(value, child)
  end

  def initialize(value, child)
    @value, @child = value, child
  end

  def each
    [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/10/28/ruby-cons/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Stolen gem name?</title>
		<link>http://nickelcode.com/2009/10/26/stolen-gem-name/</link>
		<comments>http://nickelcode.com/2009/10/26/stolen-gem-name/#comments</comments>
		<pubDate>Mon, 26 Oct 2009 21:34:30 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[uncategorized]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=634</guid>
		<description><![CDATA[[Update: Nick Quaranto was kind enough to respond to my twitter message, and the issue has been resolved. Many thanks Nick!]
So I went to publish RQuery to gem cutter but I got this lovely tidbit:

Pushing gem to Gemcutter...
You do not have permission to push to this gem.


I figured someone had clearly come up with a [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/10/26/stolen-gem-name/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Algebra of Programming: Chapter 1 section 5</title>
		<link>http://nickelcode.com/2009/09/26/algebra-of-programming-chapter-1-sections-5/</link>
		<comments>http://nickelcode.com/2009/09/26/algebra-of-programming-chapter-1-sections-5/#comments</comments>
		<pubDate>Sun, 27 Sep 2009 07:19:05 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[functional programming]]></category>
		<category><![CDATA[haskell]]></category>
		<category><![CDATA[maths]]></category>
		<category><![CDATA[programming]]></category>
		<category><![CDATA[haskell algebra functional]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=593</guid>
		<description><![CDATA[Inverses are (horrible)-1
This section gives an introduction to the extremely interesting concept of implementing a function as the inverse of another with zip and unzip as the examples. First, the goal is to build out our zip and unzip functions to satisfy the equation

zip . unzip = id


A couple of notes here. Previously everything has [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/09/26/algebra-of-programming-chapter-1-sections-5/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Algebra of Programming: Chapter 1 Section 3</title>
		<link>http://nickelcode.com/2009/09/19/algebra-of-programming-chapter-1-section-3/</link>
		<comments>http://nickelcode.com/2009/09/19/algebra-of-programming-chapter-1-section-3/#comments</comments>
		<pubDate>Sun, 20 Sep 2009 06:38:25 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[functional programming]]></category>
		<category><![CDATA[haskell]]></category>
		<category><![CDATA[uncategorized]]></category>
		<category><![CDATA[algebra programming haskell]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=567</guid>
		<description><![CDATA[Lists
The third section of chapter one covered some basic functional programming concepts. Namely Cons lists, their mirror Snoc lists, and the functions built to operate on them. Particularly the adaptations of the foldn function from the previous section which operated over Nat. 

data Listl a = Nil &#124; Snoc (Listl a, a) deriving Show
data Listr [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/09/19/algebra-of-programming-chapter-1-section-3/feed/</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>Algebra of Programming: Chapter 1 Section 2</title>
		<link>http://nickelcode.com/2009/09/12/algebra-of-programming-chapter-1/</link>
		<comments>http://nickelcode.com/2009/09/12/algebra-of-programming-chapter-1/#comments</comments>
		<pubDate>Sun, 13 Sep 2009 02:51:14 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[functional programming]]></category>
		<category><![CDATA[haskell]]></category>
		<category><![CDATA[algebra of programming]]></category>
		<category><![CDATA[functional]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=522</guid>
		<description><![CDATA[[update] you&#8217;ll notice I corrected the title to represent the section I went through. Not clear how I got the idea this was the whole first chapter.
My wife, bless her heart, heard me talking about Algebra of Programming after it was recommended to my by the fine people in #haskell and she went out and [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/09/12/algebra-of-programming-chapter-1/feed/</wfw:commentRss>
		<slash:comments>6</slash:comments>
		</item>
		<item>
		<title>RQuery: refactored and simplified</title>
		<link>http://nickelcode.com/2009/08/22/rquery-refactored-and-simplified/</link>
		<comments>http://nickelcode.com/2009/08/22/rquery-refactored-and-simplified/#comments</comments>
		<pubDate>Sat, 22 Aug 2009 21:48:36 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[programming]]></category>
		<category><![CDATA[rquery]]></category>
		<category><![CDATA[ruby]]></category>
		<category><![CDATA[rquery ruby ActiveRecord where dsl]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=492</guid>
		<description><![CDATA[I&#8217;ve gone back and knocked off a couple of big todos in rquery. Namely, removing the Symbol capability, and using instances of the new OperationCollector in place of the global class variable + mutex required by the Symbol alterations. Also, as a consequence, I was able to remove the Declarations methods ( .is, .is_not ) [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/08/22/rquery-refactored-and-simplified/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Unraverl: Partial Function Application</title>
		<link>http://nickelcode.com/2009/08/14/unraverl-partial-function-application/</link>
		<comments>http://nickelcode.com/2009/08/14/unraverl-partial-function-application/#comments</comments>
		<pubDate>Sat, 15 Aug 2009 02:51:38 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[erlang]]></category>
		<category><![CDATA[programming]]></category>
		<category><![CDATA[unraverl]]></category>
		<category><![CDATA[erlang unraverl parse transform functional]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=468</guid>
		<description><![CDATA[What is it?
Last weekend I hacked partial application into my parse transform for erlang, unraverl. The rules are very simple but the implications are interesting if nothing else.
In other functional languages, haskell as an example, there&#8217;s nothing inherently wrong with defining a function that requires two arguments but giving it one.

add x y = x [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/08/14/unraverl-partial-function-application/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Where to from here&#8230;</title>
		<link>http://nickelcode.com/2009/06/29/where-to-from-here/</link>
		<comments>http://nickelcode.com/2009/06/29/where-to-from-here/#comments</comments>
		<pubDate>Mon, 29 Jun 2009 17:33:50 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[uncategorized]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=458</guid>
		<description><![CDATA[Been mulling over my next project after I finish a small Rails app for my friend. I&#8217;m not sure I&#8217;ll have the time in the near future but here are the ideas that are competing in my head for&#8230; well literally&#8230; mind share.
Both use Erlang. Unraverl is the beginnings of a meta programming/parse transform library [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/06/29/where-to-from-here/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>
