Discover a new way to find and share stories you'll love… Learn about Reading Desk

Blog Profile / B# .NET Blog

Filed Under:Technology / Programming
Posts on Regator:37
Posts / Week:0.1
Archived Since:August 9, 2009

Blog Post Archive

Taming Your Sequence’s Side-Effects Through IEnumerable.Let

Introduction Side-effects don’t fit together very well with functional-style delayed computation, as observed in LINQ. Having such constructs embedded in an otherwise eagerly evaluated imperative language like C# can cause quite some confusion from time to time. Show More Summary

The Cruel Return of the Onderkast (Irrelevant Post for Dutch-Speaking Readers Only)

A Belgian friend of mine was looking up my obsession on lambda calculus and came across this Dutch wiki page. Reminds me of exactly the same mistake 5 years ago: [FUNNY] Rule one when translating software - review the translation. Taking the opportunity to introduce a new IIgnorable blog category for the rare occasions I feel the urge to post nonsense.

Type-Free Lambda Calculus in C#, Pre-4.0 – Defining the Lambda Language Runtime (LLR)

Introduction A while back, I blogged about (Mis)using C# 4.0 Dynamic – Type-Free Lambda Calculus, Church Numerals, and more which was a fun post and got some good feedback and solid reading numbers. So, let’s continue our journey ofShow More Summary

LINQ to Ducks – Bringing Back The Duck-Typed foreach Statement To LINQ

I promise, it will be a (relatively) short post this time. You all know the foreach statement in C#, don’t you? Think twice before you answer and tell me exactly how the following works: foreach (int x in src) {     // Do something with x. Show More Summary

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

Introduction Sunday morning, time for another episode of the Crazy Sundays series. Again one in the category with risk for exploding brains, but that’s what we like, don’t we? This time around, we’re going to have a look at the type free lambda calculus in C#. Show More Summary

Expression Trees, Take Two – Introducing System.Linq.Expressions v4.0

Introduction Avid blog readers know I have a weak spot for expression trees in particular and the broader picture of meta-programming facilities. With the introducing of LINQ in the.NET Framework 3.5 timeframe, we ended up adding expression trees to the framework as a way to represent code as data. Show More Summary

Statement Trees With Less Pain – Follow-Up on System.Linq.Expressions v4.0

Introduction In my last post, Expression Trees, Take Two – Introducing System.Linq.Expressions v4.0, I showed how to the extensions to the LINQ expression trees API opens up for full-blown statement trees including support for assignment, control flow, etc. Show More Summary

Bart’s Control Library – Not What You Think It Is – part 2

Introduction In the latest episode in this series I talked about hypothetical compile-time rewriting facilities that would be used to turn our intermediate representation of control-flow driven code using our Control Library into efficient IL code. Show More Summary

Bart’s Control Library – Not What You Think It Is – Part 1

Introduction In the last installment of our control library exploration, we kept things relatively simply by looking at the if-statement. In fact, we avoided a bunch of complications that have to do with non-local return constructs like break, continue and return (and put throw on that pile as well if you like). Show More Summary

Bart’s Control Library – Not What You Think It Is – Part 0

Wow, can’t believe how long the blog silence over here has been. Things have been quite hectic on my side the last few months, virtually running two jobs in parallel. One to cooperate in shipping our upcoming.NET 4.0 release, and one...Show More Summary

The tale of the occasional network administrator

Saturday evening, 10:30 PM, Seattle time. Window 7 RC's audio stack is pumping music from the Internet Explorer process to the laptop speakers, the process manager boosts Word 2007 with foreground priority. Bart is writing something yet unannounced. Show More Summary

Unlambda .NET – With a Big Dose of C# 3.0 Lambdas

Weekends are for hacking up crazy ideas (and so are evenings). This weekend was no different; amongst other things I got around to implement an Unlambda interpreter in C#. A what? Let’s talk about that first. Warning: Reading this post can cause permanent brain damage. Show More Summary

LINQ to Objects - Debugging

Introduction Declarative language constructs like query comprehension syntax often worries imperatively trained developers. I hear this quite a bit, and the excuse of “It Just Works” is often not satisfactory for most of them :-). Combine this with interesting behavioral differences like lazy evaluation and lots of developers get lost in paradise. Show More Summary

LINQ to Z3 – Theorem Solving on Steroids – Part 0

Introduction Last time around in this blog category we looked at using Z3 for testing satisfiability of simple Boolean logic expressions. Obviously Z3 is capable of doing much more, so this time we’ll reach out to the domain of integer value arithmetic. Show More Summary

Type Theory Essentials in Pictures – Part 1 – Answers

A while back I posted Type Theory Essentials in Pictures – Part 1 – Quiz, a series of non-annotated pictures representing concepts from type theory. Though the first part was intended to be simple, I got some feedback that people were puzzled about it… So let’s go ahead and explain it today. Show More Summary

Exploring the Z3 Theorem Prover (with a bit of LINQ)

Introduction Today I’m going to deviate from the typical path of mainstream technologies I normally cover and enter the domain of research instead. But very interesting and active research, with lots of practical implementations it turns out: theorem provers. A little story first. Show More Summary

A Whirlwind Tour through the Managed Extensibility Framework

From a hotel lobby in the sunny city of Durban, South-Africa, waiting for my plane transfer after a great TechEd Africa event. Why not write a blog post on one of my talks: the Managed Extensibility Framework, or MEF. As we steam ahead to release.NET 4.0, it’s great to see the amount of new APIs that will make it into this release. Show More Summary

Copyright © 2011 Regator, LLC