Recently I stumbled upon a post in Moirae Software blog. It was about hunting a memory leak in a F# application. What was interesting about the leak that it was caused by non-tail recursive call, however the call seemed to be tail at first glance. It turned out that tail calls is full of rather subtle pitfalls. For further information on the topic I recommend this F# team blog post. As a real engineer, I must check everything myself :) This is the results: In short, the F# team folks are absolutely right[...]

Howard Lewis wrote a nice post "Crafting Code in Clojure" about craftable code. He started with a rather ugly Java class and reached a lovely small Clojure solution. I was curious how it would be looked written in F#. Have a look at the result: It's odd that F# core library does not contain Map.keys/Map.values functions. Otherwise, the code would be a bit more shorter. However, maps aren't used in static languages like F# to represent domain types. Hence, the more idiomatic version: (the Fact attribute is[...]

‎"Programming today hasn't improved much in the last 20 years - it was mess then and it's still a mess. IDE's and revision control systems have just made matters worse - now you have all the old versions of the mess as well as the mess itself, and the IDE means you can't even see the mess. The best IDE in the world is your BRAIN - it's a zillion times better than these clicky things. Notice there is no quick fix here - if you want a quick fix go buy "learn PHP in ten minutes" and spend the next twenty yea[...]

-->Vlad Chistyakov <a href="http://www.blogger.com/comment.g?blogID=7623640872736089068&postID=2739484511886438958">suggested to use [Memoze] macro attribute</a> to speed up the Nemerle version of Fibonacci function. I don't think it's a very good idea to use macros in situations where plane functions work just well. Look at an optimized F# Fibonacci: <p><!--<pre class="fssnip"><br /><span class="l"> 1: </span><span class="k">open</span> <span onmouseout="hideTip(event, 'fst1', 1)" onmouseover="sho[...]

Micah Martin has done the Coin Change Kata in Clojure. His collegue did it in Ruby (presented in the end of the Micah's post). I don't like either of the solutions. The Clojure one is almost unreadable - it's extreamly hard to understand what's really going on - take, map, mapcat, repeat - it's just too many too general constructs for such a simple problem. The Ruby one is readable and straitforward, though it's imperative and uses mutable vars, which I don't like very much these days.So, let's look at wha[...]