Bill Blogs in C#

Reflections on Executive Briefing: Natural User Interface and Social Media

wwagner — Thu, 25 Jun 2009 15:56:56 GMT

Once again, we brought together a small group to discuss two more upcoming topics for the software industry. This time it was Natural User Interfaces and Social Media.

The most interesting observation is that there is a bigger gap between the future-oriented Natural User Interfaces and the closer-to-the-mainstream Social Media topic. That colors this post: In this group we had much more discussion on Social Media than we did on Natural User Interfaces. That's a function of the group, and the relative adoption of both topics.

Natural User Interfaces

Natural User Interfaces are a rather nascent topic in our industry. However, I do think that over the next decade, it will become more and more important. The mouse and keyboard metaphor is more than 30 years old. Gaming has clearly gone way beyond mouse and keyboard. (How long would you play rock band or guitar hero using a mouse and keyboard? Flight Simulators, racing games, and more use custom controllers that are supposedly more natural than the mouse and keyboard metaphor we’re forced to use in our regular line of business applications.

We’re starting to see some more forward looking computing devices. iPhone, iPods, Zune, Surface and Windows 7 multi-touch are all examples of a more natural user interface. In all cases, we’re using more natural motions to directly work with the device.

The conversation lagged somewhat. We didn’t have many of the devices at our disposal that day. Also, it was a bit harder to create a dynamic discussion because it was harder to get conversations about how to these new devices might map to what we do.

Social Media

Social Media was completely different. This was very lively, and it’s clear how we can all make use of social media for our business and personal endeavors.

The clearest point here is that the twitter model has won. It’s more interesting than Facebook, LinkedIn, or any other social media platform today.

The reason is that it provides the best way to reach an authentic audience from an authentic perspective.

Andy Seidl (@faseidl) has described twitter as ‘a world wide cocktail party’. That’s a very apt description. You can wade in at any time, you can choose to behave like a professional, or be that person in the corner with the lampshade on his head. You can leave conversations that aren’t interesting. But most importantly, you can engage in real conversations with those people with whom you interact.

That’s the most interesting part: Social Media must be personal in order to be useful. You can only create an audience by engaging in real conversations. Once you engage in real conversations, you can get real results.

Social Media also allows you to get around the major barriers to efficiency today. Our corporate structure exists to allow specialization, which builds walls and silos around different areas, business units, and disciplines. With a twitter presence, I’ve found it easier to reach elected officials, vendors, customers, and collaborators. I haven’t used anything else that has made it easier to reach as many people in as many ways.

Bud Gibson (@Innovators) has made significant investments in many areas of social media. He’s also claiming that twitter is a better investment than any other social media. In fact, he’s finding that twitter is better than ‘pay for click’ advertising to reach new prospective customers. It gets back to Andy’s cocktail party analogy: It’s all about the conversation.

The bulk of this was about Twitter, although we did discuss other media as well. However, most of the other social media create more walls around different communities. They are ways to interact with people you already know. Facebook and LinkedIN are platforms to talk with people you know. Twitter starts a conversation, and as part of the platform, allows anyone to join and participate.

Was there a call to action?

There was less of a call to action here. NUI seems a bit farther in the future. The call to action was to ‘keep an eye on it’. It likely will be important, but not immediately for broad reach applications.

For social media, the call to action was to develop a strategy about how to participate. Your customers are participating. Your competitors likely are too. That means you need to participate, and you need to differentiate yourself with your content.

Oh, and you can follow my updates on twitter as well: @billwagner

Reflections on Executive Briefing Event: Cloud & RIA

wwagner — Fri, 19 Jun 2009 21:43:22 GMT

Last Tuesday, we hosted our first executive briefing on upcoming technology trends. The first two topics were Cloud Computing and Rich Internet Applications (RIA). We chose those topics because examples of RIA applications are already around, and cloud computing is on the horizon. It was a great mix of present and future discussion.

Nerd Note: My regular readers that are looking for core technology content won’t find it here. Our discussions were on the business issues around these technologies. No code samples here, but there were fantastic architecture and design discussions.

Cloud Computing

I’ll start by saying that I’m personally excited about Cloud Computing. I’m spending time building applications on Azure and Live Framework.

The opening discussion centered around separating the buzzword “Cloud Computing” from the substantive advantages of using a cloud platform. The ‘Cloud Computing’ buzzword has been attached to many different activities: Google Docs can be considered cloud computing. So can LiveMail, GMail, or zune marketplace. LiveMesh is clearly a cloud based application. However, for most of us in the Software Development community, we think of cloud computing as having our own applications running in the cloud. That means Windows Azure, Amazon’s Elastic Computing Platform, or the Google App Engine. Even those this was an executive type of briefing, we are all in the software industry. We build things, so we look at tools in terms of what we can build.

From there, we discussed the risks to moving toward cloud computing. There are many.

Current Investments: A lot of the large enterprises already have significant investment in their own DataCenters. This will change the economics of moving to the cloud. Should an enterprise retire its datacenter? If so, at what cost? Having already spent all the money to build a data center, cloud computing will take much longer to generate ROI.

Sensitive Data: Others have discussed this as well,but the main concern here is fear. Many companies have entered into a trust relationship with their customers that involves how the vendor handles the customers’ data. Most vendors are concerned with offloading that trust relationship to a 3rd party. Regardless of how much trust they may place in that 3rd part already, they still have concerns. Cloud platforms increase this concern because not only is the data offsite, the data is somewhere unknown. You know, ‘it’s in the cloud’.

Spotty Connectivity: We developers tend to locate where we have great connectivity. It’s almost a prerequisite for where we choose to live and work. However, the same isn’t true for all our customers. Some of them still must live in locations where connectivity is not a given. Or, even if there is great connectivity, it may not have high enough uptimes.

But of course, we are excited about building software for the cloud, so what are the drivers to build software there? We are we excited about cloud computing?

Once again, there are a lot of great business drivers for cloud computing. However, almost all of them turn into one statement:

Cloud Computing is Elastic.

That implies several drivers for moving applications into the cloud. Economics is the greatest force: Under current models, your data center must be built to handle your peak load. You’ll pay for the infrastructure at all times, even at the minimum load for your application. For applications with seasonal implications (retail, tax applications, Olympics, etc) that can be a huge savings.

There are other drivers as well. Scale is a big one. We work with some researchers that generate terabytes of data every month. That’s an incredible expense, and cloud based computing can lower the storage costs.

After discussing some of the positives, we did a little comparing on the major announced cloud platforms. Our index-card sized comparison is this:

Amazon’s Elastic Computing is the most immediate on-ramp to the cloud.
Google App Engine is a great platform for scripted web applications.
Windows Azure is a new OS optimized for cloud computing.

Here’s why we came to that conclusion: Amazon’s platform is based on the concept of renting a virtual machine image (either Linux or Windows Server). That makes it the smallest distance from any current application architecture. Google App Engine is optimized for scripting web applications. It’s simple to create web apps there. Windows Azure is setup a bit differently, and enables you to think of an app running ‘in the cloud’ as opposed to running ‘on N servers in the cloud’. That makes it a bit more work to take advantage of the capabilities, but could be a bigger win once there.

We finished with an interesting question from one of our customers: “Are we recommending cloud computing, and if so, whose cloud?”

We all weighed in with positive comments. My own view was that if there weren’t overwhelming negatives (such as resistance to data location), I’ve been recommending cloud based solutions almost exclusively. Which cloud is trickier. I believe in the Azure vision, because even though you can leverage much of your existing skills, it does make you think about running in a cloud. Therefore, for customers invested in .NET, or open to moving there, it’s my choice. However, it’s not a good idea to recommend porting a large codebase from other platforms (java, php) just to move to Azure. I know there are some strategies for running those applications in Azure, but I don’t have enough experience there to place big bets on it. And, too many customers with Java or PHP apps have a dependency on MySQL, which doesn’t run in Azure. When those barriers are in place, Amazon’s Elastic Computing platform makes more sense.

There’s also a lot of interest from larger companies about running the Azure stack in their own data centers. Interestingly, while I understand some of the justification, I think it’s a short term concern. Why would you run your own version of the Azure stack instead of pushing your application into the immense scale of a world-wide scale cloud?

Rich Internet Applications

One great thing about conducting small seminars is that we can set the agenda and veer off that agenda as energy takes us in different directions.

On Tuesday we spent more than 3/4 of our time on cloud computing, and finished with a brief look at Rich Internet Applications.

Or rather, we talked about RunKeeper. (www.runkeeper.com) If you run, and you have an iPhone, this is incredibly cool. Take your iPhone on your run, and it maps the distance, and all elevation changes. We were discussing things like having it monitor your heartbeat, and monitor your speed (which it may do, I forget which features it does, and which we wished it did).

This one was a bit less ‘game changing’ than cloud computing. The overall consensus was that computer users want more. Better interaction, data from any device, and not constrained by the classic browser / forms metaphor. That means we may be entering a time when browser based applications will be considered ‘legacy applications’ unless they make use of Ajax, Silverlight, Flex or similar tools. It’s fun to develop applications that have different capabilities.

Closing

This was a wonderful experience. It was fantastic to spend a morning with a tremendous set of brain power, all participating in thoughtful discussions about emerging technologies and how to leverage them to bring more value and more capabilities to our customers. The best part is that some problems which were considered ‘out of scope’ are suddenly in view. That’s cool.

Reflections on our Software Development Jam

wwagner — Tue, 16 Jun 2009 19:28:24 GMT

Yesterday, we hosted a Software Development Jam at Automation Alley in Troy, MI (North suburbs of Detroit, MI for those readers not in the Michigan area).

We billed the event as a way for developers to learn something about those software techniques that we are convinced are the important areas of growth in the future. Those areas were modern software engineering techniques (TDD, Continuous Integration, distributed version control), modern .NET (WPF, Silverlight), and modern Java platform tools (Scala, Jython, JRuby). We spent the morning going over some general software techniques, discussing what kinds of apps we’d want to build, what folks wanted to learn, and why. We spent the afternoon building samples and learning from each other.

The folks that attended were an interesting mix. We had people with years of mainframe experience, people that had been teaching C++, and folks in the process of transitioning from IT Pro to developer track careers.

This was the kind of event that wouldn’t have been possible only a few years in the past. The availability of tools, frameworks, and trial editions helped. Jay Wren setup an SVN server in the meeting room on a spare laptop. Then, he helped everyone get access to it. He also setup a CC.NET server so that all the samples were building throughout the day. That was a fantastic way to show all the attendees the power of these tools. If anyone got stuck on a sample later, they could do an SVN update and see a working sample. Others could ask them to checkin their failing build and get help from someone that wasn’t stuck at the time. And the best part was that everyone could do an "SVN update” and get all the samples before leaving. Of course, everyone could see if anyone made mistakes by monitoring the CC.NET homepage on the internal LAN.

Mike Woelmer led a WPF tutorial in the afternoon. He also gave an overview of the differences between WPF and Silverlight. That helped folks understand when to pick one or the other for a new project. I was coding in Mike’s group, helping folks that got stuck. I also modified the sample so that much of the middle-tier logic used LINQ style syntax rather than the classic imperative style. Later, Mike and I collaborated on an update to a Windows Forms applications that was multithreaded to give folks an idea on how to use multi-threaded concepts in WPF.

Meanwhile, Dianne Marsh was working with a different group building some of the Code Kata problems in Scala.

All in all, we all learned quite a bit about how to apply skills used in one environment to another. Many of the attendees were stretched to apply what they know to new environments. We were all stretched to explain these new environments in a way that would resonate with people coming from a very different perspective.

We’ll definitely do more of these in the future. It was a great way to get information in front of a group of developers and understand the challenges many developers face in adopting new technologies in their current environment. That makes in incumbent upon all of us to do a better job of explaining the value proposition of the latest advances in software development.

Azure May CTP is out

wwagner — Mon, 01 Jun 2009 18:53:38 GMT

And, it’s got support for VS2010 Beta 1.

This is amazingly cool. I downloaded and installed the Azure May CTP (both the SDK and the Visual Studio Tools (link here).

Being that ‘let’s see if we can break this’ kind of person, I ran the same sample in VS2008 and VS2010 on the fabric on my box. Both ran concurrently without problems. The developer fabric kept each copy in its own sandbox.

After you get the Azure toolkit, you can get the samples (separate download for both VS2010 and VS2008) here.

Not so Hidden Gems in VS 2010

wwagner — Tue, 26 May 2009 21:25:05 GMT

I’m just going to assume that all readers of my blog know that Visual Studio 2010 Beta one has been released.

I’ve been running it almost exclusively since I downloaded and installed it. There’s a lot to like. For this first post, I’m going to limit my discussion to a very small set of IDE features that thrill me in the new release.

Tear away editor and tool windows

This is a neat feature for single monitor work, but is absolutely wonderful in a multi-monitor scenario. In VS2010, you can grab the title tab in an editor window (design or code window) and move it out of the VS IDE frame window. It’s wonderful when you’re trying to do some work that requires examining more than one code file at a time.

The fact is that this feature works for tool windows as well as editor windows. In my setup, I’ve tried to maximize my main code window in the main monitor. Properties, Solution Explorer, and the build output windows are on the secondary monitor. I’ll pull editor windows out when I need to see multiple code (or designer) files for a particular task.

PascalCased IntelliSense

Love this for discovering classes or methods in the .NET Base Class Libraries. Intellisense now picks up targets that contain the words you type, even if they are not at the beginning. For example, if you type ‘enumer’ in a code window, Intellisense will (as always) contain Enumerable. It will also contain IEnumerable, IOrderedEnumerable, and ParallelEnumerable.

It’s a great way to discover something that might be the solution to your current coding problems.

Real TDD Support: Generate From Usage

Create From Usage means you can really follow a TDD methodology. You can right test scenarios that describe how you want to use a class. Once you’ve written the test, you have a test that doesn’t compile (like now). Right click on each item with red squiggles and select “Generate”. Types allow you to generate a new class (quick default), or “Generate Other” which displays a dialog that lets you select a class, interface, enum, or struct. Furthermore, that dialog lets you select the access modifiers on the type, select a destination project (if you have multiple projects in your solution). You can follow the same workflow to generate methods or properties once you’ve created the types.

The IDE will create members that throw NotImplementedExceptions, so all your tests will fail. But, isn’t that the point of TDD? Once you have those failing tests, you have a task list to make them green.

In future posts, I’ll touch on more of the major features in VS 2010. I wanted to start with these hidden gems because they can be so easily overlooked if you just start using the new version with your old work patterns.

Upcoming Event: MI Software Stimulus Lab

wwagner — Tue, 19 May 2009 02:27:23 GMT

The software industry will be part of the underpinnings for the jobs of the future. (You can read more of my thoughts on the importance of Software to Michigan’s future here).

We created our company to create great software, and help others to do the same. In the current climate, we are holding a series of low cost labs to help developers learn skills currently in demand. Free scholarships are available for developers currently unemployed and in need of updating their skills.

The first of these labs will be at Automation Alley on Monday June 15th. You can read more about the event here. You can sign up here.

Please inform other interested developers of the event.

Query Language or Method calls: A matter of taste

wwagner — Mon, 11 May 2009 17:54:09 GMT

My last post (which was too long ago), generated question on whether I prefer the query language or the method notation for LINQ queries.

The answer is ‘yes’. Jon Skeet mentioned this as well last January, but anything you can do with query syntax can be accomplished with method calls. (Item 36 of More Effective C# discusses is some detail how the query language operators map to method calls.)

From the standpoint of correctness, you can use either construct with no differences. That means it is a matter of style whether you choose the query expressions or the method calls.

My own preference is to use the method call syntax for simpler queries, and use the query syntax for more complex query operations.

For example, I would use the method call syntax below over the query syntax:

   1: int[] numbers = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

   2: var smallNumbers = from n in numbers

   3:                    where n < 5

   4:                    select n;

5:

   6: var smallNumbers2 = numbers.Where((n) => n < 5);

However, once a query gets sufficiently complex, I believe the query syntax is more readable:

   1: int[] odds = { 1, 3, 5, 7 };

   2: int[] evens = { 2, 4, 6, 8 };

   3: var values = from oddNumber in odds

   4:             from evenNumber in evens

   5:             where oddNumber > evenNumber

   6:             select new { oddNumber, evenNumber,

   7:             Sum = oddNumber + evenNumber };

8:

   9: var values2 = odds.SelectMany(oddNumber => evens,

  10:     (oddNumber, evenNumber) =>

  11:     new { oddNumber, evenNumber })

  12:     .Where(pair => pair.oddNumber > pair.evenNumber).

  13:     Select(pair => new {

  14:         pair.oddNumber,

  15:         pair.evenNumber,

  16:         Sum = pair.oddNumber + pair.evenNumber });

In my opinion, for more complex queries, the query language produces a much more readable construct. However, on simpler queries, the method calls are easier to understand.

I like Jon’s comment: “next time you’re writing a query expression, take a look at it afterwards – it it’s simple, try writing it without the extra syntactic sugar.” (from the post referenced above).

Explain from the Questioner’s perspective, not your own

wwagner — Fri, 17 Apr 2009 02:57:25 GMT

I was involved in an interesting discussion about how the C# language has evolved, and how it’s getting harder and harder to teach developers to be proficient in the language with each passing version.

I think that’s our fault.

As leaders and experienced C# developers, we too often teach and explain from our perspective: We learned C# 1.0, learned the new features in 2.0. Then, we learned LINQ and the other syntax additions in 3.0. Now, we’re looking at adding the new 4.0 features to our repertoire of techniques. It makes sense to us, because that’s how we learned.

But we are not them.

That’s an inefficient way for someone approaching C# now to learn the language. Instead, we should explain these new concepts based on how one should learn now, not how we learned. I wish I could take credit for this amazing insight, but I must credit Bjarne Stroustrup. He wrote an essay for C++ Users Journal back in 1999 asserting that the C++ community must change how they taught developers C++. Back then, everyone teaching C++ just assumed that every novice C++ developer was a veteran C developer. And that’s how they taught. Stroustrup instead claimed that developers should learn the best C++ idioms, rather than be taught C, then how to move to C++.

Lambda Expressions as Example

Explaining Lambda expressions is a great example of what I mean in C# today.

When I explain lambda expressions to a novice C# developer, I use this example:

   1: var someNumbers = new List<int>(Enumerable.Range(-20, 200));

   2: someNumbers.RemoveAll(n => n > 30);

3:

   4: bool assertion = someNumbers.TrueForAll(n => n < 40);

Line 1 creates a collection with a bunch of numbers.

Line 2 introduces a lambda. It removes all numbers greater than 30 from the collection. The lambda expression “n => n > 30” describes the condition for all elements to be removed from the list. A lambda expression is a short hand description of a method: n is the parameter. The expression returns a boolean, the result of the test ‘n > 30’.

At this point, I’ll often get a few questions:

‘what type is n"?’

That’s easy: the compiler infers types for the parameters to lambda expressions. Here, the compiler infers that n must be integer, because the collection someNumbers contains integers.

‘there’s no return value’

Yes, I know that’s not a question. But it does express the confusion, and that’s how it’s often stated. I say that the compiler infers the return type. List.RemoveAll() takes a Predicate<T> as its parameter, and Predicate<T> returns a bool. therefore, the expression ‘n > 30’ must be a boolean expression. To illustrate this, I’ll modify the code to show how the compiler checks the type. The lambda expression ‘n => n.ToString()’ doesn’t compile, because n.ToString() evaluates to a string, not a boolean.

Then, I go on to the concept: a lambda expression is a mechanism that enables you to pass code (in the form of a lambda) to another method for execution later. Internally, List.RemoveAll() evaluates the lambda expression parameter for every element in the list. All elements that return true are removed.

I follow the same process to explain the TrueForAll() method call.

Yeah, but what about delegates, anonymous delegates and expression trees?

Those of you that are experienced C# developers are probably concerned: I didn’t mention that lambdas are implemented like anonymous delegates. I didn’t drill down further to state that anonymous delegates are just like delegates.

In short, I didn’t work back from a lambda expression to the equivalent C# 1.0 syntax. But, that’s the point. Unless you have been working with C# since the beginning, those concepts don’t help you. Someone starting to learn C# now doesn’t have that prior knowledge about C# 1.0, or C# 2.0.

Read my explanations above again. They don’t dive into great detail about how a lambda expression is interpreted by the compiler. Rather, they give you a good description of how you would write code using lambda expressions, and what they do for you.

Nothing I said is wrong, but a lot of details are left out. That’s ok, hiding details helps novices get started. We can fill in those holes as these new C# developers develop a greater understanding, and want a deeper understanding.

At that point, they are ready for a different explanation.

Until then, we are better off explaining concepts using explanations that help them, even if those explanations are different than how we learned.

Live Framework and custom resource types

wwagner — Fri, 10 Apr 2009 02:13:36 GMT

I’ll start this post with a couple caveats. I’m learning the Live Framework SDK, just everyone else. This (and upcoming) blog posts on the Live Framework are based on my initial learning on Live Framework. All the usual disclaimers apply.

My plan is to work through some of the Live Framework SDK samples. As I’m doing that, my normal work pattern is to take lots of notes on what I’m learning. My blog seems as good a place as any. Unlike posts on technologies where I’ve spent lots of time, I’m a noob on the Live Framework too. But, there’s only one way to learn.

The Project Manager Sample

I decided to start with the WPF Project Manager sample. It’s a WPF application that lets you create projects. You can add milestones to those projects. Obviously, you can edit both projects and milestones. The projects are stored as MeshObjects. The milestones are stored as DataEntries in the MeshObjects (representing projects).

This first post is mostly looking at the application, with a small look at the code.

I ran the code, created a project and some milestones. Cool enough.

Then, I went to the developer mesh website, and looked at my mesh desktop. I expected to see new folders, or something that showed the projects and milestones I created. I was surprised that nothing was there.

The answer was in the code. Remember from my first post on the Live Framework that the MyPhotos application used resource types of LiveMeshFolder, and LiveMeshFiles. That makes objects that are visible in the mesh, obviously as folders and files.

This sample uses different resources types. The sample defines a “Project” resource type for the project, and a “Milestone” type for the milestones.

Both Project and Milestone are C# classes. They are (more or less) POCO objects. They are decorated with the DataContract attribute (and their properties are decorated with the DataMember attribute).

Here’s the Project type:

   1: [DataContract(Namespace = "Microsoft.Samples.Workflow.ProjectManagerWPF")]

   2: public class Project

   3: {

   4:     /// <summary>

   5:     /// UUID of the parent MeshObject

   6:     /// </summary>

   7:     [DataMember]

   8:     public string MOID { get; set; }

   9:     /// <summary>

  10:     /// Title of the milestone (during save/update, this matches MeshObject.Resource.Title,

  11:     /// but is stored here when the custom object is databound instead of the resource)

  12:     /// </summary>

  13:     [DataMember]

  14:     public string Title { get; set; }

  15:     /// <summary>

  16:     /// Date when project will be started

  17:     /// </summary>

  18:     [DataMember]

  19:     public DateTime KickOffDate {get; set;}

  20:     /// <summary>

  21:     /// Estimated Date for Completion

  22:     /// </summary>

  23:     [DataMember]

  24:     public DateTime CompletionDate {get; set;}

  25:     /// <summary>

  26:     /// Date when project was shipped

  27:     /// </summary>

  28:     [DataMember]

  29:     public DateTime ShippedDate {get; set;}

  30:     /// <summary>

  31:     /// Description of Project

  32:     /// </summary>

  33:     [DataMember]

  34:     public string Description {get; set;}

  35: }

Storing and retrieving the Project type from the Mesh is straightforward Live Framework code. Here’s the code to read a project:

   1: //grab the Project Instance object from the mesh object and populate an instance of our Project Domain Class

   2: Library.Project SaveProject = this.ExistingProjectMeshObject.Resource.GetUserData<Library.Project>();

You simply convert the Resource to the POCO type, using the GetUserData<T> method to convert the resource. Cool. Saving it back is just as easy:

   1: MO = ExistingProjectMeshObject;

   2: SaveProject = ExistingProjectMeshObject.Resource.GetUserData<Library.Project>();

   3: MO.Resource.Title = tbTitle.Text;

4:

   5: //Set the custom attributes of the mesh object to the values from the library/domain class,

   6: //this will popualte the userfield data with the deserialized content from the Project object created above

   7: MO.Resource.SetUserData<Library.Project>(SaveProject);

8:

   9: //Set the type of the mesh object's resource to PRoject

  10: MO.Resource.Type = "Project";

11:

  12: //Update the object in the cloud.

  13: MO.Update();

The SetUserData<T> call converts the POCO Project object to a mesh resource. Then, you just need to send the data to the cloud.

Future posts will dive into the code in more detail, and start on some other mesh style programming. Just this little dive makes me think more about what I can build with this.

Euler Problem 12

wwagner — Mon, 23 Mar 2009 17:18:00 GMT

It’s been a long time since I have worked on any of the Euler problems. I simply haven’t had time. Well, it was time to spend a bit of time just exercising the math part of my mind, and solve another problem.

Problem 12 asks you to find the first triangle number that has more than 500 divisors.

Like my other C# solutions, it makes sense to decompose this problem into smaller sets. First, figure out how to generate the triangle numbers. Then, figure out the simplest way to determine how many divisors a number has.

Let’s start with the triangle numbers. The nth triangle number is the sum of all natural numbers less than or equal to N. You can think of them like the number of balls in a billiard rack with N rows: 1, (1+2), (1+2+3), (1+2+3+4), or, 1,3,6,10,15…

A little bit of math (or a quick search) will tell you that the Nth triangle number is [N * (N+1)]/2.

Now, all we need to do is compute the total number of divisors for each of these numbers. One simple answer is to take all number less than or equal to the triangle number. Any of those that divide into the triangle number is a divisor. But, that’s incredibly inefficient. Instead, you can stop at Sqrt(Number). That will give you exactly 1/2 the number of divisors. For example, if 128 is divisible by 2, you’ve found two divisors: 2, and 64. Therefore, this method tells me quickly how many divisors a number has:

   1: static int CountDivisors(int n)

   2: {

   3:     var divisors = from val in Enumerable.Range(1, (int)Math.Sqrt(n))

   4:                    where n % val == 0

   5:                    select val;

6:

   7:     return divisors.Count()*2;

   8: }

This query (written in two parts) finds the answer. Remember that one of the keys to LINQ is deferred execution. Only the triangle numbers up to and including the answer are generated. The entire program runs in a few seconds:

   1: var triangleNumbers = from n in Enumerable.Range(1, 100000)

   2:                       let Value = (n * (n + 1)) / 2

   3:                       select new

   4:                       {

   5:                           Number = Value,

   6:                           NumDivisors = CountDivisors(Value)

   7:                       };

   8: var answer = (from vals in triangleNumbers

   9:              where vals.NumDivisors > 500

  10:                   select vals).First();

It feels good to stretch the math muscles again.

Code and Slides for State of Michigan Developer Briefing

wwagner — Fri, 20 Mar 2009 02:21:00 GMT

Yesterday, a number of community leaders and Microsoft employees gave a series of presentations for developers working for the State of MI.

We spent the better part of the day discussing the current and future trends for developers on the .NET framework.

My talk was on leveraging tools to improve the quality and timeliness of your work.

You can get the slides here. And the samples here.

On craft, dogma, pragmatism and better analogies

wwagner — Tue, 24 Feb 2009 19:43:05 GMT

I’m leaping into a lengthy discussion, so I’ll start with the links:

Steve Smith wrote this post discussing the craftmanship vs. pragmatism.

Corey Haines wrote this response defending the craft movement.

And Steve responded again with this real world example.

Disclaimer: I know both Steve Smith and Corey Haines, and I have a lot of respect for both of them.

There are times when I believe we get off-track by using the wrong words, and the wrong analogies. Or, we point to the wrong evidence from the analogies.

Corey made the analogy between software and furniture: craftsmen are like the Amish craftsmen, and industrial software developers are like IKEA factories.

OK, that’s a reasonable start, and it points us to the wrong root diagnosis.

Instead, let’s look at craftsmen in the construction industry and watch everything they do. I believe Corey’s analogy only examined the finished product.

A brief side trip to real home renovations

A few years ago we put an addition on our house. A portion of the house was one story, and a portion was two stories. We built above the portion that was single story and added two bedrooms.

The final product is high quality, and my wife and I were very happy with the additions.

During the process, the carpenters built and destroyed several bits of scaffolding to make their lives easier.

The first task was to remove the old sections of roofing on the one story portion. Some of that contained beams that were holding up the roof on the two story section. It was weeks until all the framing would be done, but something had to be added to hold up the roof. One carpenter spent a half hour putting up some temporary beams. The roof stayed up.

This kind of temporary scaffolding was repeated several times through the process. One of the last tasks was to cut the doors from the existing second story into the addition. Before that was done, the carpenters built temporary steps to get up into the new section. This needed to last a month or so.

Temporary planks were laid while the framing was being constructed, before the final floor was laid.

None of these temporary tasks had the same quality that was evident in the finished product. That goes for both ‘finish features’ and engineering quality. For example, the temporary supports for the second story roof would not have withstood sustained 50 mph winds coming from the east. A real risk, but small.

In every case, the temporary solution was removed as work progressed to create the real solution.

Okay, but that’s not software

I believe there is an important analogy for software. The temporary scaffolding is analogous to technical debt. There are times when speed is more important than perfect craft. However, when that happens, you’ll incur technical debt.

Steve McConnell has an old post about Technical Debt that’s very pertinent here. In it, he separates technical debt on a number of variables. Unintentional debt, which you incur due to low quality work is always bad. That’s what Corey is protesting against. It’s insidious because you don’t even realize you’ve incurred unintentional debt.

Steve Smith is talking more about intentional debt. Here, Steve McConnell points out the difference between long-term and short-term debt: long term is strategic, and short term is tactical. Further, he describes two kinds of short term debt: ‘large chunks’ and ‘small shortcuts’. The large chunks, because of their size, have more scrutiny, and require more justification. The ‘small shortcuts’ are the kinds of quick shortcuts you do when you’re not being careful: not following your own conventions.

The purpose of this discussion on technical debt is that debt must eventually be retired. The more debt you take on (of any kind), the more cost to retire that debt. Sometimes even large debt is smart: few of us would own a home without some form of mortgage. That kind of debt is like what Smith (using last names to distinguish between Steve Smith and Steve McConnell) is discussing in his second post. The company’s very existence depends on a short release cycle. In those cases, it’s wise to take on a manageable amount of technical debt.

Focusing on the technical debt (as opposed to craft vs. pragmatism) gets you to look at the issue in a different way. No debt is always the goal; I wish I didn’t have a mortgage payment. But, smart debt is wise (I’m glad my last several years of mortgage payments have been building equity, rather than saving the full cost before buying a house. That’s true even in today’s economy). But, if you take on debt, you must pay it off. You must plan part of the budget for debt servicing.

Time for the big finish

Going back to the house renovation project, I didn’t like the appearance of the temporary scaffolding. It looked shoddy. But, I knew it was temporary, and it was the best plan to achieve the final goal. The true craftsman knows when the first effort must be the best, and when the best plan is to make a (temporary) less than optimal choice, incur the debt, and pay it off. To do that properly requires a frank and honest discussion on the tradeoffs, with a real commitment to paying off whatever technical debt is incurred in the process.

I think too many people espousing the software craftsman mantra have been burned by too many companies that incur technical debt, and refuse to pay it off until it threatens the company’s very existence. I know I’ve been involved in failed ‘legacy’ projects where the entire team couldn’t pay off the incurred debt. That memory colors your goals, and your trust with those leaders that push ‘the business goals’.

Incurring technical debt (intentionally) is not the same as low-quality work. Advocating against technical debt is not dogma. It’s only when the people asking to incur technical debt and the people advocating against it don’t have a frank discussion on the benefits and costs (both long term and short term) of the decision.

Looking at Azure

wwagner — Sat, 21 Feb 2009 19:11:59 GMT

I’m going to build on my tradition of blogging my notes as I explore new toolkits. Just like I did with LINQ, I’ll be posting blog entries about what I’ve learned as I work with the Azure platform.

Dissecting HelloFabric

I’m skipping the HelloWorld sample because the only thing I learned was that the current Device Fabric is not compatible with the Current Windows 7 beta build. Two different pre-release components, so I’m not too surprised.

HelloFabric gives a good overview of some of the basic functionality provided by the cloud infrastructure. When you run the sample, you’ll have see a simple webpage that demonstrates some of the Azure APIs.

Let’s look at the code first, and then peek at the cloud specific configuration. The first thing you see when you run the application is that it tells you if it is running in the cloud, or on a standard ASP.NET context. There’s a bit of code in the the page load handler that looks at the ApplicationEnvironment to see where it’s running.

   1: // Check if we are running in the fabric

   2: if (ApplicationEnvironment.ApplicationModel == ApplicationModel.Cloud)

   3: {

   4:     Label3.Text = "Running in the fabric." ;

   5:     if (Request.IsSecureConnection)

   6:     {

   7:         Label2.Text = "Running over a secure connection.";

   8:     }

   9:     else

  10:     {

  11:         Label2.Text = "Not running over a secure connection. Please see the documentation to test this sample with SSL.";

  12:     }

  13: }

  14: else

  15: {

  16:     Label3.Text = "Running outside the fabric.";

  17:     Label2.Text = "";

  18: }

The next item you’ll see in the page is that the label contains a set of banner text from one of the config files:

   1: Label1.Text = ApplicationEnvironment.Settings["BannerText"];

A little further down the page, you’ll see that you can enter a message that will get written to the log. The code couldn’t be much simpler:

   1: String msg = TextBox1.Text;

   2: switch (DropDownList1.Text)

   3: {

   4:     case "Alert":

   5:         ApplicationEnvironment.LogAlert(msg);

   6:         break;

   7:     case "Error":

   8:         ApplicationEnvironment.LogError(msg);

   9:         break;

  10:     case "Warning":

  11:         ApplicationEnvironment.LogWarning(msg);

  12:         break;

  13:     case "Information":

  14:         ApplicationEnvironment.LogInformation(msg);

  15:         break;

  16:     case "Verbose":

  17:         ApplicationEnvironment.LogVerbose(msg);

  18:         break;

  19:     default:

  20:         ApplicationEnvironment.LogError("Unexpected kind");

  21:         return;

  22: }

Finally, there’s a button that creates a null reference exception so you can exercise the tools that you’ll use to debug code that runs in the cloud.

You’ll note that all the code I’ve shown so far use this ApplicationEnvironment class. The ApplicationEnvironment class provides some basic capabilities that abstract away the core operating environment.

In its class constructor, it looks at the RoleManager and if the role manager is running, it determines that the operating environment is the cloud. Next, it looks to see if there is a web context. That would mean it’s running in a standard web environment. If neither of those facts are true, it assumes it is running on the desktop:

   1: protected void Button1_Click(object sender, EventArgs e)

   2: {

   3:     String msg = TextBox1.Text;

   4:     switch (DropDownList1.Text)

   5:     {

   6:         case "Alert":

   7:             ApplicationEnvironment.LogAlert(msg);

   8:             break;

   9:         case "Error":

  10:             ApplicationEnvironment.LogError(msg);

  11:             break;

  12:         case "Warning":

  13:             ApplicationEnvironment.LogWarning(msg);

  14:             break;

  15:         case "Information":

  16:             ApplicationEnvironment.LogInformation(msg);

  17:             break;

  18:         case "Verbose":

  19:             ApplicationEnvironment.LogVerbose(msg);

  20:             break;

  21:         default:

  22:             ApplicationEnvironment.LogError("Unexpected kind");

  23:             return;

  24:     }

  25: }

You’ll notice from the code above that the constructor also constructs a logger object based on where its running. A further dive into the code shows that the RoleManager class contains methods to write to a log in the Azure fabric.

   1: public override void LogAlert(string msg)

   2: {

   3:     RoleManager.WriteToLog("Critical", msg);

   4: }

The other logger implementations should be familiar to any .NET developer.

The last item you saw was reading a string from the configuration file. That’s also different in the fabric, and the ApplicationEnvironment class abstracts that away from you. To read configuration items while running in the fabric you use the RoleManager.GetConfigurationSetting method:

   1: return RoleManager.GetConfigurationSetting(name);

Of course, to read something from a config file, you’ll have to put the data in a config file. Azure changes that again. You have to define your config settings in your service definition.csdef file:

   1: <ConfigurationSettings>

   2:   <Setting name="BannerText"/>

   3:   <Setting name="LogAllRequests" />

   4:   <Setting name="LogFailedRequests" />

   5: </ConfigurationSettings>

And, you assign values to them in the ServiceConfiguration.cscfg file:

   1: <ConfigurationSettings>

   2:   <Setting name="BannerText" value="Hello Fabric!" />

   3:   <Setting name="LogAllRequests" value="false" />

   4:   <Setting name="LogFailedRequests" value="true" />

   5: </ConfigurationSettings>

Of course, you saw that there are some other settings in those config files, and that’s how logging gets enabled, and that makes use of the other classes in the Common library used in this sample.

The two boolean values affect an IHttpModule implementation that logs all requests, or just some of the requests. When the module initializes, it reads the configuration setting and attaches a handler for all requests, or just error requests. The code demonstrates how to configure logging at runtime, because there is an overhead associated with the extra logging functionality.

If you want to explore the fabric sample yourself, make sure you open the Device Fabric logger to see the logging capabilities. That’s where all the logging messages go in the end.

In some ways, Azure development, at the code level, looks boring. It’s too familiar. But then, that’s the point: Azure builds on the existing tools and libraries we already use.

Book Review: Mike Cohn X 2

wwagner — Tue, 10 Feb 2009 03:08:22 GMT

I’m covering two books by Mike Cohn in this post: User Stories Applied, and Agile Estimating and Planning.

I’m reviewing them together because I read both of them at the same time, and some of the content is inter-twined in my own mind.

Both books provide a wealth of practical advice on succeeding with an agile process. Throughout both books, the depth of Mike’s coaching experience comes through. With every element of advice, Mike includes a discussion about why each recommendation is what it is. He also includes a lot of “you may be thinking of …” comments with reasons why straying from his advice may cost you and hurt your project.

Throughout both books I found myself almost thinking Mike was inside my head, helping me improve. When an author does that, he’s clearly succeeding.

The two books are aimed at different, but overlapping audiences. Maybe because I’m in both audiences, I found both useful.

User Stories Applied goes into more depth about the process of creating user stories that will help drive your project to success. You’ll find advice that you should share with your customers. It will help them learn what makes a good user story, and how to express their needs and feature requests in the form of user stories. In addition, you and your team will gain a better understanding about creating stories that show value, are not too big, and aren’t too small to provide real value. You’ll learn how to break epics into measurable deliverables for your team. Those skills will help you succeed with agile. Software project success starts with getting good input from stakeholders and customers, regardless of which process you choose. Mike’s guidance in User Stories Applied will help your team, and your customers get this crucial part correct.

Agile Estimating and Planning provides advice from a different angle. This book explains agile techniques from all angles: release planning, iteration planning, daily planning, and modifications when reality differs from estimates (you know, like it always does). The best feature of this book is how Mike seems to anticipate counterarguments from those in any organization that would be opposed to adopting agile. He counters those arguments with clear logic and solid explanations about why following his advice will achieve better results. From different angles, you’ll find advice for developers, project leads, customers and customer proxies. Whichever role you find yourself in, read the entire book. Knowing how other team members should be approaching the process will help build a functioning team across processes.

The key theme running through this book is that agile plans must be constantly revisited, because reality changes constantly. Agile planning is not something you do at the beginning of a project, it’s a series of ongoing activities throughout the project. That point is stresses repeatedly, and it’s worth it.

If you are looking into agile, or you’ve tried an agile process and haven’t had the success you’d hoped for, you must read these books. It will help.

Duck Typing with dynamic in C# 4.0

wwagner — Fri, 06 Feb 2009 19:03:41 GMT

One of the features I find very limiting in C# (and VB.NET) generics is the way constraints work.

As you probably know, you can only specify generic constraints using interfaces, a single base class, struct or class, and the new() constraint. That makes certain constructs very difficult. For example, consider the following method:

   1: public static int Sum(this IEnumerable<int> sequence)

   2: {

   3:     int answer = default(int);

   4:     foreach (int d in sequence)

   5:     {

   6:         if (answer.Equals(default(int)))

   7:             answer = d;

   8:         else

   9:             answer = d + answer;

  10:     }

  11:     return answer;

  12: }

pedantic search note: Don’t copy this code, use Enumerable.Sum() instead.

Obviously, there’s nothing special about int in the above code. If I create a type that supports addition, I should be able to produce the Sum() for that collection. See the Vector struct and the similar extension method here:

   1: public struct Vector : IEquatable<Vector>

   2: {

   3:     public double X

   4:     {

   5:         get;

   6:         set;

   7:     }

   8:     public double Y

   9:     {

  10:         get;

  11:         set;

  12:     }

13:

  14:     public static Vector operator +(Vector left, Vector right)

  15:     {

  16:         return new Vector() { X = left.X + right.X, Y = left.Y + right.Y };

  17:     }

18:

  19:     public bool Equals(Vector other)

  20:     {

  21:         return X == other.X && Y == other.Y;

  22:     }

23:

  24:     public override bool Equals(object obj)

  25:     {

  26:         if (!(obj is Vector))

  27:             return false;

  28:         return Equals((Vector)obj);

  29:     }

  30:     public override string ToString()

  31:     {

  32:         return string.Format("X = {0}, Y = {1}", X, Y);

  33:     }

  34: }

35:

36:

  37: public static Vector Sum(this IEnumerable<Vector> sequence)

  38: {

  39:     Vector answer = default(Vector);

  40:     foreach (Vector d in sequence)

  41:     {

  42:         if (answer.Equals(default(Vector)))

  43:             answer = d;

  44:         else

  45:             answer = d + answer;

  46:     }

  47:     return answer;

  48: }

Well, that’s a lot of Ctrl-C/Ctrl-V reuse. I hate that. Unfortunately, it’s difficult to create a nice generic method using this pattern. The presence of a ‘+’ operator cannot be specified as a constraint. (A similar issue would occur with any other operator that could be overloaded.)

C# 4.0 and dynamic should make this possible.

Editors note: The following sample does not compile with the PDC bits for the C# 4.0 compiler. From my reading, I believe it should be valid C# 4.0. I’ll update this entry if I’m mis-interpreting the 4.0 dynamic features.

Instead of using generics (e.g. Sum<T>), using a dynamic type should make this work with any type that does support the ‘+’ operator. I should be able to create the sum of a sequence of integers, or a sequence of Vectors, or even a sequence of strings. The sequence of strings would concatenate the strings, because that’s how + is implemented for string.

   1: public static dynamic Sum(this IEnumerable<dynamic> sequence)

   2: {

   3:     dynamic answer = default(dynamic);

   4:     foreach (dynamic d in sequence)

   5:     {

   6:         if (answer.Equals(default(dynamic)))

   7:             answer = d;

   8:         else

   9:             answer = d + answer; // CTP:  Error CS0019

  10:     }

  11:     return answer;

  12: }

The current CTP does not provide dynamic binding for operators yet, but I believe it’s planned. See here. And here.

The more I think about dynamic types in C# 4.0, the more interesting uses I se for them.