<?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>Tue, 27 Jul 2010 00:14:41 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.0</generator>
		<item>
		<title>Middleware, Composition, and Monads</title>
		<link>http://nickelcode.com/2010/07/22/middleware-composition-and-monads/</link>
		<comments>http://nickelcode.com/2010/07/22/middleware-composition-and-monads/#comments</comments>
		<pubDate>Fri, 23 Jul 2010 02:54:00 +0000</pubDate>
		<dc:creator>John Bender</dc:creator>
				<category><![CDATA[functional programming]]></category>
		<category><![CDATA[haskell]]></category>
		<category><![CDATA[rack]]></category>
		<category><![CDATA[ruby]]></category>
		<category><![CDATA[haskell ruby rack composition monads]]></category>

		<guid isPermaLink="false">http://nickelcode.com/?p=747</guid>
		<description><![CDATA[This article pre-supposes that you have some basic knowledge of Haskell, Rack/PEP 333, and middleware. Middleware Middleware, as a plugin architecture for creating custom web stacks, is an amazing tool (the fact that it makes web servers interchangeable is equally important but not useful for this discussion). By simplifying and standardizing the interface used by [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2010/07/22/middleware-composition-and-monads/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<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 [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2010/01/10/bebop-resource-routing-for-sinatramonk/feed/</wfw:commentRss>
		<slash:comments>1</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 x = self while( x != :empty) yield x x = x.child end end end [...]]]></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 [...]]]></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. [...]]]></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 [...]]]></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 [...]]]></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 [...]]]></description>
		<wfw:commentRss>http://nickelcode.com/2009/08/14/unraverl-partial-function-application/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>
