Sunday, January 03, 2010 1:08 AM bart

Top 9 Posts from 2009

select top 9 [Subject] from dbo.cs_Posts
where postlevel = 1 and usertime < '01/01/2010' and usertime >= '01/01/2009'
order by TotalViews desc

Forgive me for the classic SQL, but here are the results with some short annotations inline:

  1. (Mis)using C# 4.0 Dynamic – Type-Free Lambda Calculus, Church Numerals, and more

    Uses the new C# 4.0 dynamic feature to implement the type-free lambda calculus consisting of an abstraction and application operator. Besides talking about the fundamentals of lambda calculus, this post shows how to implement the SKI combinators and Church Booleans, Church numerals and even recursive functions.
  2. LINQ to Ducks – Bringing Back The Duck-Typed foreach Statement To LINQ

    Since LINQ to Objects is layered on top of IEnumerable<T>, it doesn’t work against objects that just happen to implement the enumeration pattern consisting of GetEnumerator, MoveNext and Current. Since the foreach statement actually does work against such data sources, we bring back this duck typing to LINQ using AsDuckEnumerable<T>().
  3. Type-Free Lambda Calculus in C#, Pre-4.0 – Defining the Lambda Language Runtime (LLR)

    We repeat the exercise of the first blog post but now without C# 4.0 dynamic features., encoding application and abstraction operators using none less that exceptions. Those primitives define what I call the Lambda Language Runtime (LLR), which we use subsequently to implement a bunch of samples similar to the ones in the first post.
  4. Taming Your Sequence’s Side-Effects Through IEnumerable.Let

    Enumerable sequences can exhibit side-effects for various reasons ranging from side-effecting filter predicates to iterators with side-effecting imperative code interwoven in them. The Let operator introduced in this post helps you to keep those side-effects under control when multiple “stable” enumerations over the sequence are needed.
  5. Statement Trees With Less Pain – Follow-Up on System.Linq.Expressions v4.0

    The introduction of the DLR in the .NET 4 release brings us not only dynamic typing but also full-fledged statement trees as an upgrade to the existing LINQ expression trees. Here we realize a prime number generator using statement trees and runtime compilation, reusing expression trees emitted by the C# compiler where possible.
  6. LINQ to Z3 – Theorem Solving on Steroids – Part 1

    LINQifying Microsoft Research’s Z3 theorem solver has been one of my long-running side-projects. This most recent write-up on the matter illustrates the concept of a LINQ-enabled Theorem<T> and the required visitor implementation to interop with the Z3 libraries. Finally, we show a Sudoku and Kakuro solver expressed in LINQ.
  7. Expression Trees, Take Two – Introducing System.Linq.Expressions v4.0

    Just like post 5, we have a look at the .NET 4 expression tree support, now including statement trees. Besides pointing out the new tree node types, we show dynamic compilation and inspect the generated IL code using the SOS debugger’s dumpil command. In post 5, we follow up by showing how to reuse C# 3.0 expression tree support.
  8. Unlambda .NET – With a Big Dose of C# 3.0 Lambdas

    Esoteric programming languages are good topics for Crazy Sundays posts. In this one we had a look at how to implement the Unlambda language – based on SKI combinators and with “little” complications like Call/CC – using C# 3.0 with lots of lambda expressions. To satisfy our curiosity, we run a Fibonacci sample program.
  9. C# 4.0 Feature Focus – Part 4 – Co- and Contra-Variance for Generic Delegate and Interface Types

    Generic co- and contra-variance is most likely the most obscure C# 4.0 feature, so I decided to give it a bit more attention using samples of the everyday world (like apples and tomatoes). We explain why arrays are unsafe for covariance and how generic variance gets things right, also increasing your expressiveness.

In conclusion, it seems esoteric and foundational posts are quite popular, but then again that’s what I write about most. For 2010, I hope to please my readers’ interests even further with the occasional “stunt coding”, “brain pain” and “mind bending” (based on Twitter quotes in 2009). If there are particular topics you’d like to see covered, feel free to let me know. So, thanks again for reading in 2009 (good for slightly over 1TB – no that’s not a typo – of data transfer from my hoster) and hope to see you back in 2010! | Digg It | Technorati | Blinklist | Furl | reddit | DotNetKicks

Filed under:


# Dew Drop &#8211; January 3, 2009 | Alvin Ashcraft&#039;s Morning Dew

Pingback from  Dew Drop &#8211; January 3, 2009 | Alvin Ashcraft&#039;s Morning Dew

# Twitter Trackbacks for Top 9 Posts from 2009 - B# .NET Blog [] on

Pingback from  Twitter Trackbacks for                 Top 9 Posts from 2009 - B# .NET Blog         []        on

# re: Top 9 Posts from 2009

Monday, January 04, 2010 6:14 AM by Florian Reischl

Thanks for this top 9 of your most popular!

Just referred this post on twitter.



(PS: Apparently, the comment-submit button does not work for Chrome)

# Dew Drop &#8211; January 4, 2010 | Alvin Ashcraft&#039;s Morning Dew

Thursday, January 07, 2010 4:49 AM by Dew Drop – January 4, 2010 | Alvin Ashcraft's Morning Dew

Pingback from  Dew Drop &#8211; January 4, 2010 | Alvin Ashcraft&#039;s Morning Dew