<?xml version='1.0' encoding='UTF-8'?><rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/" xmlns:blogger="http://schemas.google.com/blogger/2008" xmlns:georss="http://www.georss.org/georss" xmlns:gd="http://schemas.google.com/g/2005" xmlns:thr="http://purl.org/syndication/thread/1.0" version="2.0"><channel><atom:id>tag:blogger.com,1999:blog-4101585166929239777</atom:id><lastBuildDate>Fri, 30 Aug 2024 09:16:17 +0000</lastBuildDate><category>F#</category><category>C#</category><category>async</category><category>Data structures</category><category>WebSharper</category><category>fsharp</category><category>Finger tree</category><category>Unity</category><category>VS 2010</category><category>first class events</category><category>mailboxprocessor</category><category>#ads</category><category>#announcements</category><category>.NET 4.0</category><category>2-3 tree</category><category>Active Patterns</category><category>Async.Any</category><category>DI containers</category><category>F# source</category><category>FSUG</category><category>Hindley-Milner</category><category>Iron Python</category><category>Nemerle</category><category>Python Challenge</category><category>Recursion</category><category>SRE</category><category>System.Reflection.Emit</category><category>Trampoline</category><category>WPF</category><category>call vs callvirt</category><category>dynamic</category><category>expression tree</category><category>for fun</category><category>immutability</category><category>late binding operators</category><category>macros</category><category>member constraints</category><category>message-passing</category><category>parsers</category><category>type inference</category><category>websockets</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><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#">call vs callvirt</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>(null : string).GetEnumerator() ?</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/11/null-stringgetenumerator.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>3</thr:total></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#">#announcements</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>Solving Zebra puzzle + few announcements and ads</title><atom:summary type="text">For today I have 2 news and 1 announcement:Bad (news): My F# related activities on Blogger are frozen. Here I&#39;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://v2matveev.blogspot.com/2010/10/solving-zebra-puzzle-few-announcements.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">C#</category><category domain="http://www.blogger.com/atom/ns#">Unity</category><title>Introducing UStatic: check Unity injection statically</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/10/introducing-ustatic-check-unity.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">F#</category><category domain="http://www.blogger.com/atom/ns#">FSUG</category><category domain="http://www.blogger.com/atom/ns#">WebSharper</category><title>Slides And Samples</title><atom:summary type="text">Presentation and code samples from my recent talk on FSUG meeting.     Presentation    RxJs    WebExcel   </atom:summary><link>http://v2matveev.blogspot.com/2010/09/slides-and-samples.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#</category><category domain="http://www.blogger.com/atom/ns#">F# source</category><title>F#: Building compiler from sources.</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/08/f-building-compiler-from-sources.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjhRA_wIKP-5TZwpYF3SPk_Vf9lIMG1FdwWLkmvuodpv4xOucnEJA-rNxuNIOzKq6jwrRLIH0RjFRYG2cZEZi0amxJcFs_SEN_LTsrFBRaLDJhNi05b2PZSBBEw-vD63Hjr7tYKgHaoP1M/s72-c?imgmax=800" height="72" width="72"/><thr:total>2</thr:total></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#">macros</category><category domain="http://www.blogger.com/atom/ns#">Nemerle</category><title>INotifyPropertyChanged strikes back</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/08/inotifypropertychanged-strikes-back.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>3</thr:total></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#">F#</category><category domain="http://www.blogger.com/atom/ns#">WebSharper</category><title>WebSharper, part 2: WebExcel</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/08/websharper-part-2-webexcel.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgvl0Ngypag5FtHfnIRdztqIbpfNYG1vAipmn2tt6qr7hkZzm7k3EWBRDMz4V8OacYdocb8UYWsA1cz7EDyqU_IblwvCSxUxdg1mrlyNUwZDV80WvErxZQNqceKvP-00bjzlJJHkLqKGAk/s72-c?imgmax=800" height="72" width="72"/><thr:total>0</thr:total></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 type="text">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 : &#39;T =      let prop = o.GetType().GetProperty(n)    downcast prop.GetValue(o, null)let (?&amp;lt;-) o n v =    let prop = o.GetType().GetProperty(n)    prop.SetValue(o, box v, null)let sb = new System.Text.StringBuilder()sb?Length &amp;lt;- 20let l :</atom:summary><link>http://v2matveev.blogspot.com/2010/07/tricky-late-binding-operators.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">F#</category><category domain="http://www.blogger.com/atom/ns#">WebSharper</category><title>Playing with WebSharper</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/06/playing-with-websharper.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhcOttRCIjMvmxodhfOdCwF9I0j7nbMnoWvZFleMh4Qem1mpJo_ipc3Mm6iXUz3mWlFSbFA-LHLqTT1ljQUBSpHXC0pCwdyzNEdhKbZCwR1_CiveDNlVORB2r9Cmz0IE1s310uCO61f5mg/s72-c?imgmax=800" height="72" width="72"/><thr:total>0</thr:total></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#">F#</category><category domain="http://www.blogger.com/atom/ns#">first class events</category><category domain="http://www.blogger.com/atom/ns#">fsharp</category><category domain="http://www.blogger.com/atom/ns#">member constraints</category><title>F# Performance of events (update)</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/06/f-performance-of-events-update.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">expression tree</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#">fsharp</category><title>F# Performance of events</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/06/f-performance-of-events.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">F#</category><category domain="http://www.blogger.com/atom/ns#">Hindley-Milner</category><category domain="http://www.blogger.com/atom/ns#">parsers</category><category domain="http://www.blogger.com/atom/ns#">type inference</category><title>F# Parsing simple language</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/05/f-parsing-simple-language.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">C#</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">for fun</category><category domain="http://www.blogger.com/atom/ns#">immutability</category><title>Copy-And-Update in C#</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/05/copy-and-update-in-c.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>2</thr:total></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#">Active Patterns</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>F#: Active Patterns</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/05/f-active-patterns.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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 type="text">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://v2matveev.blogspot.com/2010/04/nature-of-value-restriction.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">async</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">mailboxprocessor</category><category domain="http://www.blogger.com/atom/ns#">websockets</category><title>MailboxProcessors: Practical Application</title><atom:summary type="text">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 - &amp;quot;ping-pong&amp;quot; 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&amp;lt;unit&amp;gt; | Stoplet </atom:summary><link>http://v2matveev.blogspot.com/2010/04/mailboxprocessors-practical-application.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiDjfQFNgbqbPDTWKERtuXbZ3PQXS6ECiR336x3uBYd4lLxw6JJ2VOSOOs84nP1TUps7BA5pakSv4CAAK170R1hnVNmtgBA09qWBfIwJ4YW48po9CNQ3XdxIuRq27LQcUhZWbB3Hrz60ps/s72-c?imgmax=800" height="72" width="72"/><thr:total>4</thr:total></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#">mailboxprocessor</category><category domain="http://www.blogger.com/atom/ns#">message-passing</category><title>MailboxProcessors: Erlang-style concurrency in F#</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/04/mailboxprocessors-erlang-style.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgu9OykPv9tUJiqVyq09p_ONbQTnYwpXp431wMHCEQsLDhSsmLQsO1WGANbF693QV5-TsJWJvhkplb0PTF-k4XpyWH8Ztn4r2MrnFmNb18nxFCkCmqrQb6lneSAh50R81ER8PPUejMj93Q/s72-c?imgmax=800" height="72" width="72"/><thr:total>3</thr:total></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#">Async.Any</category><category domain="http://www.blogger.com/atom/ns#">F#</category><title>Evoking by &amp;quot;Patterns of Parallel Programming&amp;quot; 1.1</title><atom:summary type="text">In previous post I&#39;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&#39;s list all imperfections of current </atom:summary><link>http://v2matveev.blogspot.com/2010/04/evoking-by-of-parallel-programming-11.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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 &amp;quot;Patterns of Parallel Programming&amp;quot; (part 1)</title><atom:summary type="text">One section in excellent article &amp;quot;Patterns of Parallel Programming&amp;quot; is dedicated to idiom &amp;quot;Speculative processing&amp;quot;. In brief we can start multiple computation in parallel (utilizing advantages of multiple cores), take first result and ignore others. Unfortunatly F# library doesn&#39;t provide builtin primitive for this strategy. Code below contains sketch of possible solution.open</atom:summary><link>http://v2matveev.blogspot.com/2010/03/evoked-by-of-parallel-programming-part.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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 type="text">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://v2matveev.blogspot.com/2010/03/f-and-handling-aspnet-requests.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhcQg4T8-XVC94cydaJDDkyjsYNE0amZAPvH8cb0AL8QUcENOBGagmHea8yPoQHMMlfVfqlpD9TBXR1ANMHz96XJ2lQC854QgHq_m0CZH-FQQY8JKWQo_GX-aPnXbZUMVcLY44qnAab5Mk/s72-c?imgmax=800" height="72" width="72"/><thr:total>0</thr:total></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#">C#</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">Recursion</category><category domain="http://www.blogger.com/atom/ns#">Trampoline</category><title>Fun with recursion</title><atom:summary type="text">&amp;quot;To understand recursion you must understand recursion&amp;quot; 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&amp;lt;&#39;T&amp;gt; = Leaf of &#39;T | Node of Tree&amp;lt;&#39;T&amp;gt; * Tree&amp;lt;&#39;T&amp;gt;Tree is recursively defined data-type, because it </atom:summary><link>http://v2matveev.blogspot.com/2010/03/fun-with-recursion.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgOWCYKtH9HprdvqBxbZjAMpg4-1DcaDvBZXAWcusCebpdapr4KbIG_73UZkqhGhRSrfziPNn30SYPyWjTrBDW2RZtiykctqtgiRp6TRA1naVGgs-wgRrF3hoBfjUTksVZpQ4bzAlA60FU/s72-c?imgmax=800" height="72" width="72"/><thr:total>0</thr:total></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#">F#</category><category domain="http://www.blogger.com/atom/ns#">Python Challenge</category><title>Solving Python Challenge with F# - The Chronicles</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/03/solving-python-challenge-with-f.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg3xCpSYBHnAl3Jv8xWf66zpZ-J1dRedV5VruXJ7XxROHmIN_UXOc7zPaWmWlaYTCZmadZ_wj_gstBaWsbkhdYHGBM7cnsRjDEE4lMrSfju0EKuSN1925ZR57lM0XK_ResTMYRFFUVDgUA/s72-c?imgmax=800" height="72" width="72"/><thr:total>0</thr:total></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#">F#</category><category domain="http://www.blogger.com/atom/ns#">WPF</category><title>F# and WPF or how to make life a bit easier</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/03/f-and-wpf-or-how-to-make-life-bit.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>0</thr:total></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#">Data structures</category><category domain="http://www.blogger.com/atom/ns#">F#</category><category domain="http://www.blogger.com/atom/ns#">Finger tree</category><title>Data structures: Finger Tree (Part 1.5)</title><atom:summary type="text">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://v2matveev.blogspot.com/2010/03/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="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh6M-Ly5ssMgAOet9uuwPvdX9hacvSDGURPJR98KaJ5CYVKuhk466mWdTl_vZX_wy7wosphcR_ixV_qdbs2Ba2boVfmjVL8KsOjsUIKajfY7mvCZQD8KzePD8UXCFT0dmsEKZTbY5_V7VU/s72-c?imgmax=800" height="72" width="72"/><thr:total>0</thr:total></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 type="text">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://v2matveev.blogspot.com/2010/03/f-and-iron-python.html</link><author>noreply@blogger.com (Vladimir Matveev)</author><thr:total>1</thr:total></item></channel></rss>