Bill Blogs in C#

Clarifying my comments on Previous Post

wwagner — Sat, 11 Oct 2008 19:21:44 GMT

My last post generated valid criticisms from readers. Let’s clarify and correct that.

I got the impression reading your post that you "skimmed" my article and didn't really get what it was I was getting at.
[…]

The whole point of this is C# 3.0 can be written where it is unreadable (lambda as an example) but it can also make the code 200% more readable than the old way by combining several features, not just one.

Although you say you disagree, I know we both agree because we both agree the LINQ example is the most readable. Hugs all around :)

Fair enough. The title of Keith’s post certainly led me to conclude that his point was that the new syntax made for less readable code. Not his intent, and clearly my fault. My apologies for misinterpreting your intent.

Sean comments:

On the "don't use it just to use it" idea, I admit that just throwing something in can be reckless, how can you know when to use it if you don't blatantly experiment with it?

I would advocate ‘blatantly experimenting with it’. It’s a great way to learn where new features can help, and when you’ll run into weaknesses with that new feature.

But…

Before declaring a task done, take a moment and do your own review of the code. In this sense, much like Keith explored multiple solutions in his blog post, look at alternatives, determine which is the most readable, and maintainable, and go with it.

Another important technique to learn new techniques is reading code. Scott Hanselman’s “Weekly Source Code” series is great example of how to do that.

Creating Readable LINQ

wwagner — Fri, 10 Oct 2008 04:40:00 GMT

Keith Elder wrote a post a post asserting (or at least proposing) that a more imperative syntax for a problem is more readable than a LINQ based C# 3.0 version. (See here for his post). Well, that got my hackles up. Some days, my hackles get up before I do, but I digress.

His example code as examining IP addresses for a machine. His poor example was this:

        1: string ipAddy = Dns.GetHostAddresses(Dns.GetHostName()).Single(i => ValidateIP4Address(i.ToString())).ToString();
  

(ValidateIP4Address is shown in Keith’s example, and is not repeated here).

I’ll agree with Keith on one point: that’s ugly code. Formatting is only part of it. It’s also not leveraging one of the features that make LINQ readable: query expressions. It uses two different conversions from each IP address to a string. Much of the core logic is hidden.

Let’s try this instead:

   1: var ipAddy = (from address in Dns.GetHostAddresses(Dns.GetHostName())

   2:               let addressLabel = address.ToString()

   3:               where ValidateIP4Address(addressLabel)

   4:               select addressLabel).First();

The first line of the query defines the source: Host addresses.

The second line defines a local variable to cache the string representation of the address.

The third line defines the filter condition: A valid IP4 address.

And the fourth line defines the result: A single string, the first in the sequence

I’ll agree that if you haven’t looked at LINQ code very much, this can still appear hard to read. But that’s a short-term argument: If you’re reading my blog, you're a developer, and you should be learning new features in whatever language you are using.

Some of Keith’s concerns are very valid: pulling out the latest new features just to use them and experiment with whatever looks interesting will create bad code. But there is a lot to be gained by using the new features carefully, and adding them in the appropriate manner, and following the best idioms for the newer features.

There’s plenty of resources to help you. Use them, and discuss readability with your peers. It’s the only way you’ll know what other developers will understand.

Paul Kimmel interviews me about C#, LINQ, and writing books

wwagner — Mon, 06 Oct 2008 12:06:00 GMT

Paul Kimmel spent some time over the summer chatting with me about More Effective C#, LINQ, upcoming C# features, and the process of writing books. It's live here: http://www.informit.com/articles/article.aspx?p=1237069

Euler Problem 11, or it’s about time I wrote some code

wwagner — Thu, 02 Oct 2008 19:17:52 GMT

I just needed to write some code last night, so I figured I’d pull out the Euler problems and solve another.

Problem 11 asks you to find the largest product of any sequence of 4 numbers in a 20 x 20 grid. The sequence can be horizontal, vertical, or diagonal. As with the other problems, my goal is to display how C# 3.0 syntax enhancements can be best exploited for this problem.

I wrote two very similar solutions to problem 11 so that you can see how LINQ mixes imperative and functional styles, and how lazy evaluation means that the different expressions of the solution actually have similar characteristics at runtime.

The algorithm must search through the grid four times finding all the candidate sequences: horizontal, vertical, down-right, and down-left. There are four LINQ queries that find possible answer sequences. To find the single answer, you must find the max value across all four queries.

A more pure functional solution creates a single query by concatenating the four queries together. Then, after concatenating all four queries, it calls order by to find the max:

   1: var best = (from x in Enumerable.Range(0, 17) // horizontal

   2:             from y in Enumerable.Range(0, 20)

   3:             let first = data[x, y]

   4:             let second = data[x + 1, y]

   5:             let third = data[x + 2, y]

   6:             let fourth = data[x + 3, y]

   7:             let answer = first * second *

   8:                     third * fourth

   9:             select new

  10:             {

  11:                 X = x,

  12:                 Y = y,

  13:                 Direction = "Right",

  14:                 Values =

  15:                  string.Format("{0}, {1}, {2}, {3}",

  16:                     first, second,

  17:                     third, fourth),

  18:                 Answer = answer

  19:             }).Concat(from x in Enumerable.Range(0, 20) // Vertical

  20:                       from y in Enumerable.Range(0, 17)

  21:                       let first = data[x, y]

  22:                       let second = data[x, y + 1]

  23:                       let third = data[x, y + 2]

  24:                       let fourth = data[x, y + 3]

  25:                       let answer = first * second *

  26:                               third * fourth

  27:                       select new

  28:                       {

  29:                           X = x,

  30:                           Y = y,

  31:                           Direction = "Down",

  32:                           Values =

  33:                            string.Format("{0}, {1}, {2}, {3}",

  34:                               first, second,

  35:                               third, fourth),

  36:                           Answer = answer

  37:                       }).Concat(from x in Enumerable.Range(0, 17)  // Down to the right

  38:                                 from y in Enumerable.Range(0, 17)

  39:                                 let first = data[x, y]

  40:                                 let second = data[x + 1, y + 1]

  41:                                 let third = data[x + 2, y + 2]

  42:                                 let fourth = data[x + 3, y + 3]

  43:                                 let answer = first * second *

  44:                                         third * fourth

  45:                                 select new

  46:                                 {

  47:                                     X = x,

  48:                                     Y = y,

  49:                                     Direction = "DownRight",

  50:                                     Values =

  51:                                      string.Format("{0}, {1}, {2}, {3}",

  52:                                         first, second,

  53:                                         third, fourth),

  54:                                     Answer = answer

  55:                                 }).Concat(from x in Enumerable.Range(3, 17)

  56:                                           from y in Enumerable.Range(0, 17)

  57:                                           let first = data[x, y]

  58:                                           let second = data[x - 1, y + 1]

  59:                                           let third = data[x - 2, y + 2]

  60:                                           let fourth = data[x - 3, y + 3]

  61:                                           let answer = first * second *

  62:                                                   third * fourth

  63:                                           select new

  64:                                           {

  65:                                               X = x,

  66:                                               Y = y,

  67:                                               Direction = "DownLeft",

  68:                                               Values =

  69:                                                string.Format("{0}, {1}, {2}, {3}",

  70:                                                   first, second,

  71:                                                   third, fourth),

  72:                                               Answer = answer

  73:                                           }).OrderByDescending((record) => record.Answer).First();

74:

  75: Console.WriteLine(best);

Of course, many folks are turned off by seeing 70+ lines of code with a single semi-colon. So here’s a different refactoring of the same code. In the following version, I construct four different queries. It’s important to understand that constructing a query in LINQ is not the same as executing it. After constructing four distinct queries, I concatenate them, and find the max. The C# compiler can correctly determine that all four queries project a sequence of the same anonymous type, so all four query results can be concatenated. (If you really want, you can look in Reflector and find that the compiler generates only one anonymous type for the query result objects.)

var horizontal = from x in Enumerable.Range(0, 17) // horizontal

                 from y in Enumerable.Range(0, 20)

                 let first = data[x, y]

                 let second = data[x + 1, y]

                 let third = data[x + 2, y]

                 let fourth = data[x + 3, y]

                 let answer = first * second *

                         third * fourth

                 select new

                     X = x,

                     Y = y,

                     Direction = "Right",

                     Values =

                      string.Format("{0}, {1}, {2}, {3}",

                         first, second,

                         third, fourth),

                     Answer = answer

};

var vertical = from x in Enumerable.Range(0, 20) // Vertical

               from y in Enumerable.Range(0, 17)

               let first = data[x, y]

               let second = data[x, y + 1]

               let third = data[x, y + 2]

               let fourth = data[x, y + 3]

               let answer = first * second *

                       third * fourth

               select new

                   X = x,

                   Y = y,

                   Direction = "Down",

                   Values =

                    string.Format("{0}, {1}, {2}, {3}",

                       first, second,

                       third, fourth),

                   Answer = answer

};

var downRight = from x in Enumerable.Range(0, 17)  // Down to the right

                from y in Enumerable.Range(0, 17)

                let first = data[x, y]

                let second = data[x + 1, y + 1]

                let third = data[x + 2, y + 2]

                let fourth = data[x + 3, y + 3]

                let answer = first * second *

                        third * fourth

                select new

                    X = x,

                    Y = y,

                    Direction = "DownRight",

                    Values =

                     string.Format("{0}, {1}, {2}, {3}",

                        first, second,

                        third, fourth),

                    Answer = answer

};

var downLeft = from x in Enumerable.Range(3, 17)

               from y in Enumerable.Range(0, 17)

               let first = data[x, y]

               let second = data[x - 1, y + 1]

               let third = data[x - 2, y + 2]

               let fourth = data[x - 3, y + 3]

               let answer = first * second *

                       third * fourth

               select new

                   X = x,

                   Y = y,

                   Direction = "DownLeft",

                   Values =

                    string.Format("{0}, {1}, {2}, {3}",

                       first, second,

                       third, fourth),

                   Answer = answer

};

var best = horizontal.

    Concat(vertical).

    Concat(downRight).

    Concat(downLeft).

    OrderByDescending((record) => record.Answer).First();

Console.WriteLine(best);

There’s one other interesting bit of syntax that should be noted here. I’ve used ‘let’ in all the queries to avoid recomputing the same result, and to ensure that I’ve avoided any copy/paste errors as I put together the answer.

DNR TV on C# 3.0 is live

wwagner — Mon, 29 Sep 2008 16:23:00 GMT

Last week, I recorded a DNR TV with Carl Franklin discussing C# 3.0 extension methods, local type inference and some of the best practices that revolve around those parts of the languages.

It's up and live now. Check it out here.

Cloud Computing: A new place for my stuff?

wwagner — Thu, 25 Sep 2008 02:47:52 GMT

One of the big areas of coverage for this year's PDC (http://www.microsoftpdc.com) is Microsoft's cloud computing platform. You've already seen some of the concept with LiveMesh (www.LiveMesh.net). The long list of talks on cloud computing, working with Live Mesh, and similar topics make me think there is clearly a lot more under the covers here.

Personally, I'm hoping for a clear programming model that lets me use the clould for storing all my data. I've said before about relational databases: It's just a place for my stuff. I'm more than happy to let others that are more skilled in T-SQL and optimizing that layer handle the particulars. It's a place for my stuff.

I'm hopeful that the cloud computing model is similar: I want to view the cloud as a place for my stuff. It should be that simple.

And, like the old George Carlin monologue, I want to take some of my stuff with me. No matter where I go, I want to get at my stuff.

That's why I'm going to PDC: I want to know as much as I can about this model, so I can get my apps and my customers ready to leverage it as soon as it's ready for use.

The monster hard drive with the goods must have some cloud bits on it.

Note on the video: Might not be safe for work (It's George Carlin, and it uses a few words some may not like).

George Carlin's "A Place for My Stuff"

I'm a PC

wwagner — Mon, 22 Sep 2008 21:30:00 GMT

The I'm a PC ads are great.

I like the tone, the content, and the message: PCs create are world without walls, where communication is world wide, different industries, hobbies, goals, and types of hardware are supported. It's great, and shows the incredible breadth and diversity of the PC and Windows community. Breadth of interests, breadth in geography, breadth of thought, breadth of problems, breadth of solutions.

You can view the videos here.

If you're different, not like that monolithic Mac world, you can upload your photo or video here: http://imapc.lifewithoutwalls.com

Channel 9 interview with the VS.NET IDE team

wwagner — Tue, 09 Sep 2008 17:01:00 GMT

Is located here. It's well worth 30 minutes of your time.

Observation: Dustin is fitting in quite well with a great team.

My 24 hours with Chrome

wwagner — Thu, 04 Sep 2008 23:53:18 GMT

Or the luster is already gone.

I used Chrome for some of my web browsing for about one day. It works alright, but it's clearly an early release. Technically, Chrome can and will compete with Firefox 3 and IE 8. (I'm running a beta of IE 8 as my regular browser at the moment.)

The reason I removed Chrome is entirely based on the EULA (even though it is changing). It may be a bit of paranoia, but it is my opinion.

I freely admit to having concerns about Google and privacy, more so than any other software company. That's entirely because of their business model. Other software companies want an ongoing relationship with their customers. That shortens the sales cycle. But Google is different. Google doesn't sell me anything. It sells access to me (and others like me) to advertisers. The more demographic information they have about me (and others like me) the better they are able to satisfy their customers: the advertisers. It's in their business interest to collect as much data about their users as possible. Note that I make the distinction between users and customers: Advertisers are Google's customers. You and I (and others like us) are users. Google must satisfy its customers: the advertisers.

Despite such platitudes as "don't be evil", Google must keep advertisers happy if they are to succeed. Keeping users happy is important only in so much as a lack of any users will affect how well Google can sell add space.

That analysis makes me somewhat concerned anytime Google wants to know something about me (and others like me). They have a profit motive to know enough about me to target ads at me (and others like me). I prefer Google know less about me.

If you've read anything about Chrome's EULA, you know that I'm concerned about Chrome, and Google's ability to track my every move online. They have a profit motive to know as much as possible. The biggest risk of this, (to me) is the way their Omnibar can track everything I type. Depending on Google's use of that data, it's almost spyware.

The EULA has another clause (which Google is updating, but I haven't seen the updates) that gives Google a non-exclusive license to all content created with Chrome. That's also clearly part of Google's profit motive: the more content they can deliver to end users, the more advertisers are willing to pay Google to deliver ads. The simplest answer is that I don't intend to give Google (or anyone else) that kind of broad license.

I'm sure Google will continue to address these issues over time, and I'm also sure I'll give Chrome another look as they do so. In the meantime, I will be watching how much marketshare Chrome achieves. At the moment, I don't expect it will grow quickly: too many people have similar concerns about the EULA, and the privacy concerns.

Euler Problem 10

wwagner — Sun, 31 Aug 2008 17:05:00 GMT

Patrick posted his solution earlier this week. I figure it was time to add mine.

Also, Octavio Hernandez pointed out in the comments to problem 8 that he had discussed similar code constructs in his blog a while back.

Problem 10 asks for the sum of all primes less than 2 million. It's also one line of LINQ code:

   1: var number = Common.Primes.GeneraePrimes().TakeWhile((n) => n < 2000000).Sum();

   2: Console.WriteLine(number);

As Patrick pointed out, this will cause an overflow unless you make some changes to the GeneratePrimes() method so that it returns a sequence of longs instead of a sequence of ints.

I also wasn't thrilled with the fact that it was taking a few minutes to finish instead of seconds. That needed some fixing.

George Byrkit pointed out that the math can be optimized by recognizing that the highest factor you need to check for any N is Sqrt(N).

Sadly, the current .NET Framework does not contain methods that do the check efficiently. George suggested using List<T>FindAll() to find only those numbers smaller than the target. That method is a member of List and creates a new List object. Yuck. Also, it doesn't perform lazy evaluation, and it checks the entire list.

But now that the numbers have gotten much larger, it's worth the work to create my own version of those methods that speed this up.

Here's the new version of IsPrime:

   1: public static IEnumerable<long> GeneratePrimes()

   2: {

   3:     var range = Enumerable.Range(2, int.MaxValue-1);

   4:     var answers = from number in range

   5:                   where number.IsPrime()

   6:                   select (long)number;

7:

   8:     return answers;

   9: }

The only change here is to cast the prime number to a long before returning.

IsPrime gets a slightly larger makeover:

   1: private static bool IsPrime(this int number)

   2: {

   3:     bool isPrime = knownPrimes.TakeWhile(n => n*n <= number).

   4:         TrueForAll(n => number % n != 0);

   5:     if (isPrime)

   6:         knownPrimes.Add(number);

   7:     return isPrime;

   8: }

The astute reader will immediately notice that I'm calling TrueForAll using an IEnumerable<int> instead of a List<int>. That's not supposed to compile. And in fact, it doesn't, until I write my own version of TrueForAll:

   1: public static bool TrueForAll<T>(this IEnumerable<T> sequence, Predicate<T> test)

   2: {

   3:     foreach (T item in sequence)

   4:         if (!test(item))

   5:             return false;

   6:     return true;

   7: }

Note that this is typed for IEnumerable<T>, so the compiler will use this version on sequences that are not List<T>, but will still use the base framework version for all List<T> types.

And, now it produces the correct answers in under a minute.