<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" media="screen" href="/~d/styles/rss2full.xsl"?><?xml-stylesheet type="text/css" media="screen" href="http://feeds.feedburner.com/~d/styles/itemcontent.css"?><rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearch/1.1/" xmlns:georss="http://www.georss.org/georss" xmlns:gd="http://schemas.google.com/g/2005" xmlns:thr="http://purl.org/syndication/thread/1.0" xmlns:feedburner="http://rssnamespace.org/feedburner/ext/1.0" version="2.0"><channel><atom:id>tag:blogger.com,1999:blog-4101585166929239777</atom:id><lastBuildDate>Wed, 21 Sep 2011 15:10:44 +0000</lastBuildDate><category>late binding operators</category><category>F# source</category><category>call vs callvirt</category><category>Async.Any</category><category>for fun</category><category>first class events</category><category>dynamic</category><category>Python Challenge</category><category>Data structures</category><category>macros</category><category>expression tree</category><category>Iron Python</category><category>System.Reflection.Emit</category><category>SRE</category><category>VS 2010</category><category>type inference</category><category>Recursion</category><category>websockets</category><category>F#</category><category>immutability</category><category>#ads</category><category>#announcements</category><category>DI containers</category><category>WebSharper</category><category>C#</category><category>FSUG</category><category>Active Patterns</category><category>2-3 tree</category><category>fsharp</category><category>.NET 4.0</category><category>parsers</category><category>Unity</category><category>Nemerle</category><category>mailboxprocessor</category><category>Trampoline</category><category>member constraints</category><category>async</category><category>WPF</category><category>Hindley-Milner</category><category>message-passing</category><category>Finger tree</category><title>Occasional notes</title><description>geeky notes: F#/C#, persistent data structures, async workflows, etc...</description><link>http://v2matveev.blogspot.com/</link><managingEditor>noreply@blogger.com (Vladimir Matveev)</managingEditor><generator>Blogger</generator><openSearch:totalResults>33</openSearch:totalResults><openSearch:startIndex>1</openSearch:startIndex><openSearch:itemsPerPage>25</openSearch:itemsPerPage><atom10:link xmlns:atom10="http://www.w3.org/2005/Atom" rel="self" type="application/rss+xml" href="http://feeds.feedburner.com/OccasionalNotes" /><feedburner:info uri="occasionalnotes" /><atom10:link xmlns:atom10="http://www.w3.org/2005/Atom" rel="hub" href="http://pubsubhubbub.appspot.com/" /><feedburner:feedFlare href="http://add.my.yahoo.com/rss?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://us.i1.yimg.com/us.yimg.com/i/us/my/addtomyyahoo4.gif">Subscribe with My Yahoo!</feedburner:feedFlare><feedburner:feedFlare href="http://www.newsgator.com/ngs/subscriber/subext.aspx?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.newsgator.com/images/ngsub1.gif">Subscribe with NewsGator</feedburner:feedFlare><feedburner:feedFlare href="http://feeds.my.aol.com/add.jsp?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://o.aolcdn.com/favorites.my.aol.com/webmaster/ffclient/webroot/locale/en-US/images/myAOLButtonSmall.gif">Subscribe with My AOL</feedburner:feedFlare><feedburner:feedFlare href="http://www.bloglines.com/sub/http://feeds.feedburner.com/OccasionalNotes" src="http://www.bloglines.com/images/sub_modern11.gif">Subscribe with Bloglines</feedburner:feedFlare><feedburner:feedFlare href="http://www.netvibes.com/subscribe.php?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.netvibes.com/img/add2netvibes.gif">Subscribe with Netvibes</feedburner:feedFlare><feedburner:feedFlare href="http://fusion.google.com/add?feedurl=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://buttons.googlesyndication.com/fusion/add.gif">Subscribe with Google</feedburner:feedFlare><feedburner:feedFlare href="http://www.pageflakes.com/subscribe.aspx?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.pageflakes.com/ImageFile.ashx?instanceId=Static_4&amp;fileName=ATP_blu_91x17.gif">Subscribe with Pageflakes</feedburner:feedFlare><feedburner:feedFlare href="http://www.plusmo.com/add?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://plusmo.com/res/graphics/fbplusmo.gif">Subscribe with Plusmo</feedburner:feedFlare><feedburner:feedFlare href="http://www.thefreedictionary.com/_/hp/AddRSS.aspx?http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://img.tfd.com/hp/addToTheFreeDictionary.gif">Subscribe with The Free Dictionary</feedburner:feedFlare><feedburner:feedFlare href="http://www.bitty.com/manual/?contenttype=rssfeed&amp;contentvalue=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.bitty.com/img/bittychicklet_91x17.gif">Subscribe with Bitty Browser</feedburner:feedFlare><feedburner:feedFlare href="http://www.live.com/?add=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://tkfiles.storage.msn.com/x1piYkpqHC_35nIp1gLE68-wvzLZO8iXl_JMledmJQXP-XTBOLfmQv4zhj4MhcWEJh_GtoBIiAl1Mjh-ndp9k47If7hTaFno0mxW9_i3p_5qQw">Subscribe with Live.com</feedburner:feedFlare><feedburner:feedFlare href="http://mix.excite.eu/add?feedurl=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://image.excite.co.uk/mix/addtomix.gif">Subscribe with Excite MIX</feedburner:feedFlare><feedburner:feedFlare href="http://www.webwag.com/wwgthis.php?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.webwag.com/images/wwgthis.gif">Subscribe with Webwag</feedburner:feedFlare><feedburner:feedFlare href="http://www.podcastready.com/oneclick_bookmark.php?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.podcastready.com/images/podcastready_button.gif">Subscribe with Podcast Ready</feedburner:feedFlare><feedburner:feedFlare href="http://www.wikio.com/subscribe?url=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.wikio.com/shared/img/add2wikio.gif">Subscribe with Wikio</feedburner:feedFlare><feedburner:feedFlare href="http://www.dailyrotation.com/index.php?feed=http%3A%2F%2Ffeeds.feedburner.com%2FOccasionalNotes" src="http://www.dailyrotation.com/rss-dr2.gif">Subscribe with Daily Rotation</feedburner:feedFlare><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-3407301679702519381</guid><pubDate>Sun, 07 Nov 2010 11:47:00 +0000</pubDate><atom:updated>2010-11-07T13:47:47.773+02:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">call vs callvirt</category><title>(null : string).GetEnumerator() ?</title><atom:summary>Little quiz, guess what will be the result of the code below:((string)null).GetEnumerator(); //C#Obvious, isn’t it? And what about this?(null : string).GetEnumerator() //F#Expecting NullReferenceException? Well, time for little dissapointment, because this code will be compiled and executed without any errors. How can this happen, we expicitly invoke method with null instance and haven’t received</atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/ZI9gd16a_TA/null-stringgetenumerator.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>3</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ZI9gd16a_TA:ig_xrNxYzbA:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ZI9gd16a_TA:ig_xrNxYzbA:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ZI9gd16a_TA:ig_xrNxYzbA:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ZI9gd16a_TA:ig_xrNxYzbA:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ZI9gd16a_TA:ig_xrNxYzbA:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/ZI9gd16a_TA" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/11/null-stringgetenumerator.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7329159823396079269</guid><pubDate>Thu, 07 Oct 2010 00:25:00 +0000</pubDate><atom:updated>2010-10-07T03:28:15.809+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">#ads</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">#announcements</category><title>Solving Zebra puzzle + few announcements and ads</title><atom:summary>For today I have 2 news and 1 announcement:Bad (news): My F# related activities on Blogger are frozen. Here I'll publish only general .NET/C# programming stuff, so do not remove me from your RSS feeds :).Good (news): I didn’t give up F# blogging, moreover I’ll try to increase quality of posts. Please meet my new blog on IntelliFactory website together with the first post: Solving Zebra Puzzle. </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/F_w6ud6TtcU/solving-zebra-puzzle-few-announcements.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=F_w6ud6TtcU:Tk2vw4WQPxo:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=F_w6ud6TtcU:Tk2vw4WQPxo:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=F_w6ud6TtcU:Tk2vw4WQPxo:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=F_w6ud6TtcU:Tk2vw4WQPxo:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=F_w6ud6TtcU:Tk2vw4WQPxo:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/F_w6ud6TtcU" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/10/solving-zebra-puzzle-few-announcements.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7181883861491194329</guid><pubDate>Mon, 04 Oct 2010 21:42:00 +0000</pubDate><atom:updated>2010-10-05T02:47:22.061+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Unity</category><category domain="http://www.blogger.com/atom/ns#">C#</category><title>Introducing UStatic: check Unity injection statically</title><atom:summary>A few months ago I’ve made post about wrapper over Unity container that allows to verify object structure during compilation. At that time this wrapper supports only one type of injection – through properties (setter injection). Today it evolve into more evil and aggressive creature that besides property injection can initialize objects through calling specified constructors (constructor </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/sePJT4tdWNE/introducing-ustatic-check-unity.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=sePJT4tdWNE:2zbOxCIbThE:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=sePJT4tdWNE:2zbOxCIbThE:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=sePJT4tdWNE:2zbOxCIbThE:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=sePJT4tdWNE:2zbOxCIbThE:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=sePJT4tdWNE:2zbOxCIbThE:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/sePJT4tdWNE" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/10/introducing-ustatic-check-unity.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-8433712331472646660</guid><pubDate>Tue, 14 Sep 2010 00:04:00 +0000</pubDate><atom:updated>2010-09-14T03:04:55.034+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">FSUG</category><category domain="http://www.blogger.com/atom/ns#">WebSharper</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>Slides And Samples</title><atom:summary>Presentation and code samples from my recent talk on FSUG meeting.     Presentation    RxJs    WebExcel   </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/ydAtbkaXKh8/slides-and-samples.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ydAtbkaXKh8:wcr0V9nw2hM:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ydAtbkaXKh8:wcr0V9nw2hM:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ydAtbkaXKh8:wcr0V9nw2hM:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ydAtbkaXKh8:wcr0V9nw2hM:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ydAtbkaXKh8:wcr0V9nw2hM:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/ydAtbkaXKh8" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/09/slides-and-samples.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-1979832524299070642</guid><pubDate>Sun, 29 Aug 2010 22:36:00 +0000</pubDate><atom:updated>2010-08-30T01:41:45.290+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">F# source</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>F#: Building compiler from sources.</title><atom:summary>I think every curious person couldn’t resist from peeking when he met folder named Source inside F# installation directory. And what can be funnier that browsing through the source code of real-world compiler? Of course, compiling them sources and observing all internal compiler activities, so to say “in action’.You need F# 2.0 and F#PowerPack to be installed. Additionaly we’ll build a few </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/QR3UbmCYqQ0/f-building-compiler-from-sources.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh6.ggpht.com/_L1oqV6qAZ20/THrgtZZKaqI/AAAAAAAAAw0/KYy4ScvaMds/s72-c/1.%20set%20path_thumb%5B2%5D.png?imgmax=800" height="72" width="72" /><thr:total>2</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=QR3UbmCYqQ0:GDVF2H79Mh8:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=QR3UbmCYqQ0:GDVF2H79Mh8:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=QR3UbmCYqQ0:GDVF2H79Mh8:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=QR3UbmCYqQ0:GDVF2H79Mh8:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=QR3UbmCYqQ0:GDVF2H79Mh8:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/QR3UbmCYqQ0" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/08/f-building-compiler-from-sources.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7942853555204849266</guid><pubDate>Sat, 14 Aug 2010 12:05:00 +0000</pubDate><atom:updated>2010-08-14T15:08:10.201+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Nemerle</category><category domain="http://www.blogger.com/atom/ns#">macros</category><title>INotifyPropertyChanged strikes back</title><atom:summary>This short post was inspired by this question on StackOverflow. Questioner asks for some language-specific features that can simplify tracking of changes in objects. This task can be perfectly solved by language that supports compile-time metaprogramming, unfortunately F# doesn’t have such features… maybe only in some distant future. Let’s demonstrate the solution using language that already has </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/ykk3rXIf7nM/inotifypropertychanged-strikes-back.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>3</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ykk3rXIf7nM:drknsDjNCZI:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ykk3rXIf7nM:drknsDjNCZI:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ykk3rXIf7nM:drknsDjNCZI:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ykk3rXIf7nM:drknsDjNCZI:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ykk3rXIf7nM:drknsDjNCZI:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/ykk3rXIf7nM" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/08/inotifypropertychanged-strikes-back.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-3475958249520829254</guid><pubDate>Mon, 09 Aug 2010 18:47:00 +0000</pubDate><atom:updated>2010-08-10T11:17:22.939+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">WebSharper</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>WebSharper, part 2: WebExcel</title><atom:summary>Well, after the long pause, I came back to blogging and today out test pet once again will be WebSharper. However now we’ll make pure client-side application so it can reveal all (or mostly all) positive sides of WS.Today’s demo project will be modestly codenamed WebExcel – simple spreadsheet with support of formulae.All major components of our system and relations between them are shown on the </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/-e9bUSYtS7A/websharper-part-2-webexcel.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh6.ggpht.com/_L1oqV6qAZ20/TGB5BjgLjxI/AAAAAAAAAjI/rgb_OHnpePI/s72-c/diagram_thumb%5B8%5D.png?imgmax=800" height="72" width="72" /><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=-e9bUSYtS7A:7zIze_3wNJo:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=-e9bUSYtS7A:7zIze_3wNJo:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=-e9bUSYtS7A:7zIze_3wNJo:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=-e9bUSYtS7A:7zIze_3wNJo:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=-e9bUSYtS7A:7zIze_3wNJo:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/-e9bUSYtS7A" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/08/websharper-part-2-webexcel.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-5776936201402039604</guid><pubDate>Wed, 21 Jul 2010 16:52:00 +0000</pubDate><atom:updated>2010-07-21T19:52:02.220+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">dynamic</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">late binding operators</category><title>Tricky late binding operators</title><atom:summary>F# Dynamic and DynamicAssignment operators are not as simple as they appear ex facte. Most popular sample of their usage is something like this:let (?) o n : 'T =      let prop = o.GetType().GetProperty(n)    downcast prop.GetValue(o, null)let (?&lt;-) o n v =    let prop = o.GetType().GetProperty(n)    prop.SetValue(o, box v, null)let sb = new System.Text.StringBuilder()sb?Length &lt;- 20let l : int =</atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/D2wnbR512-4/tricky-late-binding-operators.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=D2wnbR512-4:h4LLYbzTJc0:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=D2wnbR512-4:h4LLYbzTJc0:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=D2wnbR512-4:h4LLYbzTJc0:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=D2wnbR512-4:h4LLYbzTJc0:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=D2wnbR512-4:h4LLYbzTJc0:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/D2wnbR512-4" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/07/tricky-late-binding-operators.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7873382769918518421</guid><pubDate>Wed, 16 Jun 2010 22:17:00 +0000</pubDate><atom:updated>2010-06-17T01:17:26.668+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">WebSharper</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>Playing with WebSharper</title><atom:summary>I’ve decided to make post about WebSharper long time ago…and finally time has come :). The idea behind the WebSharper is not new, compilers that translate some source language to JavaScript already exists (for example GWT). Main distinguished feature of WS is using F# as a source language: built-in metaprogramming capabilities, type inference, succinct and expressive syntax, seamless integration </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/1z82SBcIR9M/playing-with-websharper.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh4.ggpht.com/_L1oqV6qAZ20/TBlNY7pHBrI/AAAAAAAAAgc/rh7x0r3nBTk/s72-c/initial_thumb%5B4%5D.png?imgmax=800" height="72" width="72" /><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=1z82SBcIR9M:EQhexThVNWw:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=1z82SBcIR9M:EQhexThVNWw:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=1z82SBcIR9M:EQhexThVNWw:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=1z82SBcIR9M:EQhexThVNWw:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=1z82SBcIR9M:EQhexThVNWw:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/1z82SBcIR9M" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/06/playing-with-websharper.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7276213128670628409</guid><pubDate>Tue, 08 Jun 2010 06:01:00 +0000</pubDate><atom:updated>2010-06-08T09:12:42.800+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">fsharp</category><category domain="http://www.blogger.com/atom/ns#">member constraints</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">first class events</category><title>F# Performance of events (update)</title><atom:summary>There is another solution to the challenge we’ve met last time. In my previous post I’ve skipped it because it is F# specific and result cannot be used directly in other languages. However after discussion with ControlFlow I think this solution is also worth mentioning. As you remember the problem was inability to call Invoke method of the delegate. Using statically resolved type parameters and </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/k3qV2fTletg/f-performance-of-events-update.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=k3qV2fTletg:6EOd1lfxfgg:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=k3qV2fTletg:6EOd1lfxfgg:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=k3qV2fTletg:6EOd1lfxfgg:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=k3qV2fTletg:6EOd1lfxfgg:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=k3qV2fTletg:6EOd1lfxfgg:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/k3qV2fTletg" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/06/f-performance-of-events-update.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-3670278962685795614</guid><pubDate>Sat, 05 Jun 2010 09:26:00 +0000</pubDate><atom:updated>2010-06-08T20:34:06.204+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">fsharp</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">first class events</category><category domain="http://www.blogger.com/atom/ns#">expression tree</category><title>F# Performance of events</title><atom:summary>Events in F# are first class citizens, and this is in fact feature with vast amount of applications. We can compose events using combinators, pass events to functions, return them as a results… IDelegateEvent wrap delegates and under the hood use Delegate.DynamicInvoke for invoking methods bound to delegate, causing significant performance degradation. Rick Minerich has made good description of </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/r0klPre9IxI/f-performance-of-events.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=r0klPre9IxI:QyvlMJuRXWI:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=r0klPre9IxI:QyvlMJuRXWI:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=r0klPre9IxI:QyvlMJuRXWI:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=r0klPre9IxI:QyvlMJuRXWI:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=r0klPre9IxI:QyvlMJuRXWI:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/r0klPre9IxI" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/06/f-performance-of-events.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7636665676053833772</guid><pubDate>Sat, 29 May 2010 08:11:00 +0000</pubDate><atom:updated>2010-05-31T16:42:07.130+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">parsers</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">type inference</category><category domain="http://www.blogger.com/atom/ns#">Hindley-Milner</category><title>F# Parsing simple language</title><atom:summary>During my professional career I often met the task of code generation based on some source data. Last time it was analogue of BCL compiler for ExpressionTrees and then C# compiler have done mostly all the required job with parsing expressions. It is time to invert our responsibilities and feel ourselves in the shoes of compiler. As a test animal we’ll take MiniML-like language (without binary/</atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/fMTPa1KNWCQ/f-parsing-simple-language.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=fMTPa1KNWCQ:ystH1nH_xYY:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=fMTPa1KNWCQ:ystH1nH_xYY:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=fMTPa1KNWCQ:ystH1nH_xYY:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=fMTPa1KNWCQ:ystH1nH_xYY:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=fMTPa1KNWCQ:ystH1nH_xYY:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/fMTPa1KNWCQ" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/05/f-parsing-simple-language.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7380315954759004832</guid><pubDate>Tue, 18 May 2010 14:53:00 +0000</pubDate><atom:updated>2010-05-18T22:06:26.375+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">for fun</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">immutability</category><category domain="http://www.blogger.com/atom/ns#">C#</category><title>Copy-And-Update in C#</title><atom:summary>Disclaimer: only for demonstration purposes :).Immutability is natural for F# types; tuples, lists and records are immutable by default. Also records have special syntax “copy-and-update” that allows creation copy of existing record specifying only modified fields.type DataObject =     { Id : int      Value : string      Object : DataObject2 }and DataObject2 =     { Price : decimal      PriceType</atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/6-FgIOvsGsQ/copy-and-update-in-c.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>2</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=6-FgIOvsGsQ:Ob3yHBc7xBg:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=6-FgIOvsGsQ:Ob3yHBc7xBg:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=6-FgIOvsGsQ:Ob3yHBc7xBg:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=6-FgIOvsGsQ:Ob3yHBc7xBg:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=6-FgIOvsGsQ:Ob3yHBc7xBg:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/6-FgIOvsGsQ" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/05/copy-and-update-in-c.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-6463422496082564451</guid><pubDate>Sat, 15 May 2010 15:49:00 +0000</pubDate><atom:updated>2010-05-15T18:55:11.282+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">Active Patterns</category><title>F#: Active Patterns</title><atom:summary>Introduction  Pattern matching is an extremely powerful feature supported by F#. Ability to decompose composite data structure into constituent parts (recursively by support of nested patterns) makes analysis of complex objects a piece of cake. As a sample we can take insertion operation for AVL tree and implement tree rotation with pattern matching. Entire process is nicely demonstrated on the </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/Yj6AXzd2ZsQ/f-active-patterns.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=Yj6AXzd2ZsQ:n_LwEI7sun4:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=Yj6AXzd2ZsQ:n_LwEI7sun4:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=Yj6AXzd2ZsQ:n_LwEI7sun4:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=Yj6AXzd2ZsQ:n_LwEI7sun4:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=Yj6AXzd2ZsQ:n_LwEI7sun4:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/Yj6AXzd2ZsQ" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/05/f-active-patterns.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-7434755266084183479</guid><pubDate>Thu, 29 Apr 2010 19:22:00 +0000</pubDate><atom:updated>2010-04-30T10:20:05.890+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">F#</category><title>Nature of value restriction</title><atom:summary>IntroductionValue restriction is an error that firstly makes a direct hit in the brain of non-prepared developer. It has no straight analogues in the majority of mainstream languages and thus very confusing. Fortunately error message produced by compiler contains comprehensive solution. However IMO good developer cannot use the tool without having a knowledge how it works under the hood. </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/wDdo7FGArAM/nature-of-value-restriction.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=wDdo7FGArAM:eb6bvyCRQoE:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=wDdo7FGArAM:eb6bvyCRQoE:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=wDdo7FGArAM:eb6bvyCRQoE:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=wDdo7FGArAM:eb6bvyCRQoE:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=wDdo7FGArAM:eb6bvyCRQoE:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/wDdo7FGArAM" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/04/nature-of-value-restriction.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-1457959714730064563</guid><pubDate>Sun, 18 Apr 2010 19:30:00 +0000</pubDate><atom:updated>2010-04-20T12:05:04.073+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">websockets</category><category domain="http://www.blogger.com/atom/ns#">async</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">mailboxprocessor</category><title>MailboxProcessors: Practical Application</title><atom:summary>Last time we have examined the API of MailboxProcessors. Now it is time to see, how this concept can be applied to solve real-world problems.Just as a quick reminder - "ping-pong" sample: two mailboxes, first one sends Ping request to second one, second replies with Pong. After specified number of iteratons execution stops.type Message = Ping of AsyncReplyChannel&lt;unit&gt; | Stoplet pong (inbox : </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/t5jsQQMaCos/mailboxprocessors-practical-application.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh5.ggpht.com/_L1oqV6qAZ20/S8tdmCWh17I/AAAAAAAAAec/CcnP518n7oo/s72-c/Server_thumb%5B1%5D.png?imgmax=800" height="72" width="72" /><thr:total>4</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=t5jsQQMaCos:YIEdUQb1Rtc:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=t5jsQQMaCos:YIEdUQb1Rtc:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=t5jsQQMaCos:YIEdUQb1Rtc:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=t5jsQQMaCos:YIEdUQb1Rtc:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=t5jsQQMaCos:YIEdUQb1Rtc:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/t5jsQQMaCos" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/04/mailboxprocessors-practical-application.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-1675513306170085292</guid><pubDate>Mon, 12 Apr 2010 15:31:00 +0000</pubDate><atom:updated>2010-09-02T12:33:07.240+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">message-passing</category><category domain="http://www.blogger.com/atom/ns#">mailboxprocessor</category><title>MailboxProcessors: Erlang-style concurrency in F#</title><atom:summary>Erlang is the language designed by Ericsson with primary application domain: distributed, fault-tolerant applications. The basic concurrency-related unit in Erlang - lightweight process. These processes has nothing similar with processes of OS, but rather green threads. Processes comminicate by asynchronous copy-nothing message-passing: every process has associated mailbox with messages yet </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/exj-FL3LrwE/mailboxprocessors-erlang-style.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh6.ggpht.com/_L1oqV6qAZ20/S8M8osoITQI/AAAAAAAAAeE/UOhRr1qkeXE/s72-c/mailboxprocessor_thumb%5B6%5D.png?imgmax=800" height="72" width="72" /><thr:total>3</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=exj-FL3LrwE:rjk4ixEAHiY:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=exj-FL3LrwE:rjk4ixEAHiY:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=exj-FL3LrwE:rjk4ixEAHiY:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=exj-FL3LrwE:rjk4ixEAHiY:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=exj-FL3LrwE:rjk4ixEAHiY:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/exj-FL3LrwE" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/04/mailboxprocessors-erlang-style.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-2674619118877366720</guid><pubDate>Fri, 02 Apr 2010 19:30:00 +0000</pubDate><atom:updated>2010-04-03T19:58:22.885+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">async</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">Async.Any</category><title>Evoking by "Patterns of Parallel Programming" 1.1</title><atom:summary>In previous post I've made the sketch of Async.Any method, however code in sample should not be treated as a real-world implementation but rather as a demonstration of approach. Now we will improve existing version so the interest to it can be switched from academical to practical. Many thanks to Dmitry Lomov, as he reveals number of very serious flaws.Let's list all imperfections of current </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/LWlORKAk8jI/evoking-by-of-parallel-programming-11.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=LWlORKAk8jI:-CmiCWIuwHU:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=LWlORKAk8jI:-CmiCWIuwHU:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=LWlORKAk8jI:-CmiCWIuwHU:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=LWlORKAk8jI:-CmiCWIuwHU:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=LWlORKAk8jI:-CmiCWIuwHU:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/LWlORKAk8jI" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/04/evoking-by-of-parallel-programming-11.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-3723771867464866292</guid><pubDate>Tue, 30 Mar 2010 21:45:00 +0000</pubDate><atom:updated>2010-04-02T22:33:40.274+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">async</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>Evoked by "Patterns of Parallel Programming" (part 1)</title><atom:summary>One section in excellent article "Patterns of Parallel Programming" is dedicated to idiom "Speculative processing". In brief we can start multiple computation in parallel (utilizing advantages of multiple cores), take first result and ignore others. Unfortunatly F# library doesn't provide builtin primitive for this strategy. Code below contains sketch of possible solution.open </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/nhK0qRnW8k0/evoked-by-of-parallel-programming-part.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=nhK0qRnW8k0:WA_iyHJFqEo:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=nhK0qRnW8k0:WA_iyHJFqEo:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=nhK0qRnW8k0:WA_iyHJFqEo:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=nhK0qRnW8k0:WA_iyHJFqEo:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=nhK0qRnW8k0:WA_iyHJFqEo:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/nhK0qRnW8k0" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/03/evoked-by-of-parallel-programming-part.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-5794339365488068096</guid><pubDate>Tue, 30 Mar 2010 20:36:00 +0000</pubDate><atom:updated>2010-03-31T11:31:00.846+03:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">F#</category><title>F# and handling ASP.NET requests</title><atom:summary>Recently I’ve browsed through the old files and occasionaly found a description of the practical task given to me when I was still a student. Objective was the following: implement simple socket based application that will listen specified port, parse incoming HTTP requests (extract uri from request treating it as file) and return content of specified file. Roughly speaking it should be primitive</atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/yWX6AnsS33w/f-and-handling-aspnet-requests.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh5.ggpht.com/_L1oqV6qAZ20/S7Jg01FPQEI/AAAAAAAAAd0/raMvV_pTcRQ/s72-c/req1_thumb%5B2%5D.png?imgmax=800" height="72" width="72" /><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=yWX6AnsS33w:l5fPGvBudJE:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=yWX6AnsS33w:l5fPGvBudJE:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=yWX6AnsS33w:l5fPGvBudJE:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=yWX6AnsS33w:l5fPGvBudJE:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=yWX6AnsS33w:l5fPGvBudJE:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/yWX6AnsS33w" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/03/f-and-handling-aspnet-requests.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-1294787580175133867</guid><pubDate>Fri, 26 Mar 2010 15:16:00 +0000</pubDate><atom:updated>2010-03-27T11:54:35.163+02:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Recursion</category><category domain="http://www.blogger.com/atom/ns#">Trampoline</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">C#</category><title>Fun with recursion</title><atom:summary>"To understand recursion you must understand recursion" Recursion is an extremly useful tool in the toolbox of every developer. Many problems have recursive nature and thus best solved with recursion. Tree-like stucture is a very nice candidate for demonstration.type Tree&lt;'T&gt; = Leaf of 'T | Node of Tree&lt;'T&gt; * Tree&lt;'T&gt;Tree is recursively defined data-type, because it contains values that are Tree </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/z4werjtOAVQ/fun-with-recursion.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh5.ggpht.com/_L1oqV6qAZ20/S6zP2Chcb0I/AAAAAAAAAck/2i19v12RGDI/s72-c/t1_thumb%5B1%5D.png?imgmax=800" height="72" width="72" /><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=z4werjtOAVQ:sNb6uYTZ_00:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=z4werjtOAVQ:sNb6uYTZ_00:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=z4werjtOAVQ:sNb6uYTZ_00:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=z4werjtOAVQ:sNb6uYTZ_00:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=z4werjtOAVQ:sNb6uYTZ_00:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/z4werjtOAVQ" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/03/fun-with-recursion.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-3987297768300387597</guid><pubDate>Mon, 22 Mar 2010 23:34:00 +0000</pubDate><atom:updated>2010-03-23T10:14:11.889+02:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Python Challenge</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>Solving Python Challenge with F# - The Chronicles</title><atom:summary>Recently I have tested my skills in Python Challenge and I definitly recommend this set of puzzles to everyone who likes quests and/or programming. Some of riddles require usage of Python standard library but others can be easily solved with arbitrary language. So my Python challenge was in fact Python/F# :) WARNING!!! If you are going to pass through the Python challenge then stop reading this </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/8AydSRWArC8/solving-python-challenge-with-f.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh4.ggpht.com/_L1oqV6qAZ20/S6f-iC3QcMI/AAAAAAAAAcU/W7nmJ6UK3Ag/s72-c/maze_thumb%5B2%5D.png?imgmax=800" height="72" width="72" /><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=8AydSRWArC8:KtcW_BkYqWo:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=8AydSRWArC8:KtcW_BkYqWo:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=8AydSRWArC8:KtcW_BkYqWo:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=8AydSRWArC8:KtcW_BkYqWo:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=8AydSRWArC8:KtcW_BkYqWo:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/8AydSRWArC8" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/03/solving-python-challenge-with-f.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-284987343152064354</guid><pubDate>Thu, 18 Mar 2010 18:37:00 +0000</pubDate><atom:updated>2010-03-18T20:39:46.341+02:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">WPF</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>F# and WPF or how to make life a bit easier</title><atom:summary>I like F#. It combines power of functional programming and features of OO languages so you can mix together most convinient features from both worlds. Ex facte it can appear as a esotheric language with unfriendly syntax (especially for fans of C-like languages) but after first week of using it you begin to notice the verbosity of other languages. In fact learning ways of solving problems in F# </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/ouO_MPBMJd4/f-and-wpf-or-how-to-make-life-bit.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ouO_MPBMJd4:-Lgeyk5_dsA:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ouO_MPBMJd4:-Lgeyk5_dsA:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ouO_MPBMJd4:-Lgeyk5_dsA:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=ouO_MPBMJd4:-Lgeyk5_dsA:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=ouO_MPBMJd4:-Lgeyk5_dsA:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/ouO_MPBMJd4" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/03/f-and-wpf-or-how-to-make-life-bit.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-457019468858834615</guid><pubDate>Thu, 18 Mar 2010 00:43:00 +0000</pubDate><atom:updated>2010-03-18T02:43:07.930+02:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">Finger tree</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">Data structures</category><title>Data structures: Finger Tree (Part 1.5)</title><atom:summary>Last time we stopped on “immutable deque” stage. Today we will explore a few additions that can endow deque with super (hmm..human/deque?) powers.Random accessOne of the most popular and claimed abilities of data structures nowadays is random access. The BCL leader in this category is undoubtedly List (O(1)), in opposite LinkedList has the worst results - O(N). What should we change in structure </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/htpot6YRJzY/data-structures-finger-tree-part-15.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://lh3.ggpht.com/_L1oqV6qAZ20/S6F3EnsHKbI/AAAAAAAAAcA/W64bGoxPExs/s72-c/annotated_tree_thumb%5B3%5D.png?imgmax=800" height="72" width="72" /><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=htpot6YRJzY:3U4FbimjUww:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=htpot6YRJzY:3U4FbimjUww:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=htpot6YRJzY:3U4FbimjUww:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=htpot6YRJzY:3U4FbimjUww:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=htpot6YRJzY:3U4FbimjUww:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/htpot6YRJzY" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/03/data-structures-finger-tree-part-15.html</feedburner:origLink></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-4101585166929239777.post-5315008037428577495</guid><pubDate>Fri, 12 Mar 2010 17:57:00 +0000</pubDate><atom:updated>2010-03-13T01:51:39.282+02:00</atom:updated><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">Iron Python</category><title>F# and Iron Python</title><atom:summary>Iron Python - .NET implementation of Python, tightly integrated with .NET framework, has a wide range of applications. It can be used as an embedded scripting language, as a full-fledged language for creating complex apps and as a bridge for reusing existing Python code in managed programs. The latter benefit is very important because Python offers huge amount of various libraries distributed as </atom:summary><link>http://feedproxy.google.com/~r/OccasionalNotes/~3/lBFprfKyBEM/f-and-iron-python.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total><description>&lt;div class="feedflare"&gt;
&lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=lBFprfKyBEM:TfzC_w3uj4U:yIl2AUoC8zA"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?d=yIl2AUoC8zA" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=lBFprfKyBEM:TfzC_w3uj4U:F7zBnMyn0Lo"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=lBFprfKyBEM:TfzC_w3uj4U:F7zBnMyn0Lo" border="0"&gt;&lt;/img&gt;&lt;/a&gt; &lt;a href="http://feeds.feedburner.com/~ff/OccasionalNotes?a=lBFprfKyBEM:TfzC_w3uj4U:V_sGLiPBpWU"&gt;&lt;img src="http://feeds.feedburner.com/~ff/OccasionalNotes?i=lBFprfKyBEM:TfzC_w3uj4U:V_sGLiPBpWU" border="0"&gt;&lt;/img&gt;&lt;/a&gt;
&lt;/div&gt;&lt;img src="http://feeds.feedburner.com/~r/OccasionalNotes/~4/lBFprfKyBEM" height="1" width="1"/&gt;</description><feedburner:origLink>http://v2matveev.blogspot.com/2010/03/f-and-iron-python.html</feedburner:origLink></item></channel></rss>

