<?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>Code Obscurata &#187; metaprogramming</title>
	<atom:link href="http://nealabq.com/blog/category/metaprogramming/feed/" rel="self" type="application/rss+xml" />
	<link>http://nealabq.com/blog</link>
	<description>... dodging grues in the dark</description>
	<lastBuildDate>Mon, 08 Nov 2010 17:26:59 +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>Meta functions and parallel programming: map, filter, and reduce</title>
		<link>http://nealabq.com/blog/2009/03/27/meta-functions-and-parallel-programming-map-filter-and-reduce/</link>
		<comments>http://nealabq.com/blog/2009/03/27/meta-functions-and-parallel-programming-map-filter-and-reduce/#comments</comments>
		<pubDate>Sat, 28 Mar 2009 02:14:15 +0000</pubDate>
		<dc:creator>Neal</dc:creator>
				<category><![CDATA[Programming]]></category>
		<category><![CDATA[metaprogramming]]></category>
		<category><![CDATA[parallel processing]]></category>

		<guid isPermaLink="false">http://nealabq.com/blog/?p=1169</guid>
		<description><![CDATA[(This is a continuation of my previous post, Why is parallel programming difficult?.) When programming, we&#8217;re always dealing with collections &#8212; objects that hold other objects. You cannot go far without them &#8212; they&#8217;re as fundamental as bools and forks (if statements). In Erlang and Lisp we often use lists as the default generic collection. [...]]]></description>
		<wfw:commentRss>http://nealabq.com/blog/2009/03/27/meta-functions-and-parallel-programming-map-filter-and-reduce/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Transformative pattern: re-factoring a function to make it tail recursive</title>
		<link>http://nealabq.com/blog/2009/01/08/transformative_pattern/</link>
		<comments>http://nealabq.com/blog/2009/01/08/transformative_pattern/#comments</comments>
		<pubDate>Thu, 08 Jan 2009 23:36:37 +0000</pubDate>
		<dc:creator>Neal</dc:creator>
				<category><![CDATA[Programming]]></category>
		<category><![CDATA[erlang]]></category>
		<category><![CDATA[metaprogramming]]></category>

		<guid isPermaLink="false">http://nealabq.com/blog/?p=790</guid>
		<description><![CDATA[A few days ago I talked a little about tail recursion, and I mentioned a pattern I called iterator/builder to transform some simple recursive functions into tail-recursive functions. The transformation looks like this (in Erlang). % not tail recursive factorial_a( 0 ) -> 1; factorial_a( N ) -> N * factorial_a( N - 1 ). [...]]]></description>
		<wfw:commentRss>http://nealabq.com/blog/2009/01/08/transformative_pattern/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Erlang as C++ code generator</title>
		<link>http://nealabq.com/blog/2009/01/02/erlang/</link>
		<comments>http://nealabq.com/blog/2009/01/02/erlang/#comments</comments>
		<pubDate>Fri, 02 Jan 2009 23:16:51 +0000</pubDate>
		<dc:creator>Neal</dc:creator>
				<category><![CDATA[C/C++]]></category>
		<category><![CDATA[Code]]></category>
		<category><![CDATA[erlang]]></category>
		<category><![CDATA[metaprogramming]]></category>

		<guid isPermaLink="false">http://nealabq.com/blog/?p=708</guid>
		<description><![CDATA[In my last post I talked about how templates could be extended to manipulate and transform bits of the C++ syntax tree. Parsed C++ syntax objects, like block statements and parameter lists, are just the kind of thing you need when generating code. But there are other ways to approach the problem. You can generate [...]]]></description>
		<wfw:commentRss>http://nealabq.com/blog/2009/01/02/erlang/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Templates and the C++ syntax tree</title>
		<link>http://nealabq.com/blog/2008/12/26/template_syntax_tree/</link>
		<comments>http://nealabq.com/blog/2008/12/26/template_syntax_tree/#comments</comments>
		<pubDate>Sat, 27 Dec 2008 00:34:00 +0000</pubDate>
		<dc:creator>Neal</dc:creator>
				<category><![CDATA[C/C++]]></category>
		<category><![CDATA[metaprogramming]]></category>

		<guid isPermaLink="false">http://nealabq.com/blog/?p=689</guid>
		<description><![CDATA[In my last few posts I&#8217;ve been writing about C++0x templates. Specifically I&#8217;ve been talking about how to make template classes easier to read by allowing more-imperative/less-declarative and more-iterative/less-recursive class definitions. I&#8217;ve talked about extending the &#8230; packing operator and adding code-generating scripting to the compiler. The C++ compiler already has &#8220;scripting&#8221; of sorts, in [...]]]></description>
		<wfw:commentRss>http://nealabq.com/blog/2008/12/26/template_syntax_tree/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

