Beautiful code — The Manifesto (bestinclass.dk)

You seem to be intentionally taking that Clojure code out of context. The refactored of version of that code, which compares much more favorably with your C# 3.0 version, was given as:

  (reduce (sum-field :productioncost) 0
     (filter doubleMargin?
           (map attach-liquid-value assets)))

  (from asset in assets
   let liquidValue = GetLiquidValue(asset)
   where DoubleMargin(asset, liquidValue)
   select liquidValue).Sum()

agreed. i think his C# code is intentionally obtuse or something. and the 'refactored' version of the Clojure code with the gnarly bits removed is missing the logic to actually perform the calculations.

speaking of functional, i'm new to Haskell, but wouldn't it just be

  f x = sum [v | (y,z) <- x, let v = y*z, v >= z*2]

assuming the argument is a list of tuples in the form (SDFactor, productionCost)

you could also foldl if you don't trust the compiler to optimize the extra list iteration away.

i didn't really like the article. the tone was really grating. probably look elsewhere if you want some inspiration on functional programming style

Linq is indeed nice. The Clojure code can be made easier to understand using a list comprehension:

    (reduce + 
      (for [{:keys [productioncost sdfactor]} assets
            :let [liquidvalue (* productioncost sdfactor)]
            :when (> liquidvalue (* productioncost 2))]
        productioncost))

I can point to a Clojure line that has similar characteristics (and I don't even know Clojure):

(+ 1 1)

Done. Clojure's awesome, right? No errors. That rocks, huh?

No. Even that line has the potential for errors:

  1. You could have a typo (int z = 6; int x = 7;)
  2. You could have misunderstood the requirements (it should actually be float x = 6.5)

The only possibility you excluded with this trivially simple line is:

  3. An error in how you used your own tools (easier to imagine if the line involved pointers).

Part of the difficulty of debugging is, you don't know which lines have errors in them. If you have 1000 lines, you potentially have to review them all to find the bug. If those lines are poorly compartmentalised, so that you can't heuristically find your way to the likely location of the bug, that is doubly the case. Conversely, if you only have 20 lines of code, then you only have 20 lines to read before you've definitely seen the line with the bug (whether you recognise it is another matter, which has more to do with experience, capability, and the clarity of the code).

Intention-revealing code does tend to be much, much clearer, though. (although I'll grant you it's possible to obfuscate code with malevolent intent).

@snprbob86: I don't mind you moving comments from my blog to HN, but I do mind you misquoting and thereby lying publicly - it's not good for you and it's not good for me.

Here the full quote: "Hi all — I’m serving up the first comment!

I’ve received about 6 comments from C# developers all giving me their take on a better version of the liquid-value code above. A couple of them using Linq, which simplifies the code substantially. I’ve taken a drastic step in deleting all those comments — sorry guys!!

Not because they didn’t present valid points, but because they entirely missed the point — I tried to spell it out with the K example — We’re discussing principles here, not code examples. I have no doubt that my rusty C# can be written in a more idiomatic sense, using better libraries etc. But thats much beside the point. The point is, that while the language so freely permits and even encourages me to code that way — I will end up seeing that type of code in my systems. If I had the privilege of hiring a team of superior geniuses and unspeakable coding skills, then sure, they might consistently produce rock solid functional code even in C# — but that’s not a real world scenario.

So lets stick with the principles. And if anybody does provide examples, please connect them with something discussed in the post. That makes for a better discussion than just swapping code.

Thanks to all for taking the time, sorry for being so harsh /Lau"

  (from asset in assets
   let liquidValue = GetLiquidValue(asset) // 1
   where DoubleMargin(asset, liquidValue)  // 2
   select liquidValue).Sum()               // 3

  (reduce (sum-field :productioncost) 0       ; 3
     (filter doubleMargin?                    ; 2
           (map attach-liquid-value assets))) ; 1

  sum(liquid_value                           # 3
      for liquid_value, asset in assets
      (get_liquid_value(asset), asset        # 1
       for asset in assets)
      if double_margin(asset, liquid_value)) # 2