Bill Blogs in C#

C# can now consume indexed properties

wwagner — Sun, 01 Nov 2009 19:39:35 GMT

Kirill Osenkov provides some details on this feature that was added in Beta 2 of C#4.0. I must admit a certain ambivalence toward this feature. On the one hand, this feature will make working with Office COM APIs even easier (as Kirill shows). On the other hand, I fear a rising chorus asking to implement defining indexed properties in C#. That would be a mistake. It would end muddling the waters of what objects ‘owned’ other objects and properties.

foo.SomeProperty[3]

could represent two very different object models. Is SomeProperty a type that implements an indexer? Or is SomeProperty a property of foo that requires an index? That starts to matter quite a bit when you wonder about LINQ queries and other ways to access whatever data is behind SomeProperty.

I’m close to thinking that I’d have preferred this change wasn’t made. It’s a bit troubling to think that the language accepted changes solely to support interop with COM style APIs. But as long as the indexed properties remain in a box, and are only used for that particular scenario, it won’t be a serious concern.

Advice for Public Speakers

wwagner — Tue, 27 Oct 2009 03:01:58 GMT

A friend of mine asked me for some pointers relating to giving technical talks recently. We had a great discussion and I thought that some of the advice was general enough that I would share it here. Many of us are involved in user groups, and we (as a community) owe it to our other members to help everyone learn.

Of course, I’m not the world’s authority on speaking, and I have quite a bit to learn. I want to hear your speaking tips as well.

Tell a Story

View your talk as a story, in the literary sense. This has a lot of implications in your talk. First, think about books you really like (or even a movie). The very beginning hooks the audience immediately. You may not know much about the story yet, but you are hooked. You need to know more. OK, I admit that very few tech talks have the same hook as “Raiders of the Lost Ark”. But still, work on the hook as much as you can.

Next, continuing the ‘story’ analogy, consider the different components of your talk as characters in the story. Your story (at least for this talk) revolves around one topic. All other topics. are supporting characters. They are part of the story, but they have supporting roles. Do not spend more time on these supporting roles than they deserve. That limits your ability to tell the main story. These supporting characters can be covered, but only in such as these supporting characters tell your main story. Look through your slides, and your samples and look for opportunities to focus on your main story rather than these supporting characters. For example, if your talk is about C# 4.0, you may use a Silverlight application to demonstrate the features. Concentrate on C# 4.0, not Silverlight. (Of course, if your talk is about Silverlight, you do exactly the opposite).

Everyone Needs Practice

Listen to yourself. Do you have an verbal tics? ‘Um’, ‘So…’, Most of us have them. Work on minimizing those tics. They will hurt your delivery.

Mix up the slides and demos. Almost all great speakers split up the cadence of their talk. They do some discussion. Then some demos. Back to slides, or a story, and onward. Staying in any one of those styles for too long will lose the audience.

Demos need the Most Practice

Let’s talk about demos. That is the hardest part. It’s hard because we usually don’t speak while we are coding, and no one likes ‘dead air’. That’s why I use the trick of saying what I’m coding. It avoids ‘dead air’ and I’ve never been able to code one thing while saying something else. It’s usually something like:

“I’ll new up a List of Employees so that I can run a few queries. We’ll have to initialize it with some data. (see note one below). Now that we’ve got a collection let’s find the most expensive employees. That’s a query from emp in employees where salary is …”

By talking through the code, you can keep your focus.

Note: some code is not relevant to your talk, like initializing a collection with a bunch of values. Use a snippet, or already have that written. When you practice, you’ll spot these. They are the bits of code that you don’t want to talk about, because they aren’t part of the story. Just put them in place, and move on. It will give you more time to talk about your main story.

Have the crutches handy

There are two crutches I have ready all the time:

Snippets for bits of code I forget. Everything I type is on the snippet clipboard, in case I forget something. I try not to just paste code, but it helps to know that I can grab those if something bombs.
The finished demo somewhere on disk. I’ve often forgot some small bit needed to make the demo work right. It’s easy to do on stage. And, when a demo doesn’t work, it’s easy to get really nervous really fast. Therefore, I always have a way to get to the finished working demo quickly. When the demo bombs, I’ll try to fix it once. If I can’t get it working with one quick session, I punt and say something like “I must have forgotten something, so let’s load the finished solution and look at it. We’ll find what I missed, and you’ll never forget to do that again. Especially if forgetting it means your demo doesn’t work and look foolish on stage.” Then, I load the finished solution. I run and prove to the audience that it works. Then, I look at the code and explain what’s in the pre-loaded solution that wasn’t in the demo that broke. (Trust me, it’s really easy to find.)

Finally, you have to use the big font. And, you have to practice with it because that will make sure you format code so it looks good on the big screen.

The more you practice, the better you’ll be. Talk to any experienced speaker, and you’ll hear stories of when that person gave a talk that felt like a failure. They are great speakers because they learned from that experience. Everyone can do it, but it does take practice.

VS2010 Beta 2, Release dates, and More

wwagner — Mon, 19 Oct 2009 17:39:00 GMT

You probably noticed that Visual Studio 2010 Beta 2 was released for download today (for MSDN subscribers). The general release will be Wednesday (Oct 21).

I’ve had limited time (obviously) to work with this, but I’m already impressed. The WPF editor has shown lots of progress. It’s much more responsive than in earlier beta builds. The language features (at least for C#) are coming along well.

That bodes well for the announced release date of March 22, 2010. Yes, they’ve placed a stake in the ground, and this release has an official launch date.

In addition, Microsoft made some announcements about MSDN licensing and pricing. Microsoft has the full announcement here. There are a couple of interesting items that are very important in this announcement:

1. Every Visual Studio Premium license includes Team Foundation Server with 1 Cal. That means if your team has VS Premium, you can use TFS right out of the box.

2. WIndows Azure “Development and Test Use”. Visual Studio Premium (and above) will include compute hours (and data storage) in Windows Azure for test purposes. (UPDATE: The full terms are here.) VS2010 with Premium MSDN will get (initially) 750 hours of compute time per month, 10 Gigabytes of storage, and more).

That promises to be a very exciting 2010!

Lazy: On Demand Construction in .NET 4.0

wwagner — Wed, 30 Sep 2009 23:32:00 GMT

I love it when I find those small new bits of functionality in the .NET framework. It’s all the big items that get all the love at conferences and in magazines.

Lazy<T> is one of those items.

Let’s imagine you’re writing an application and in some scenarios, but not others, you need a particular object. Furthermore, suppose that object you need is very expensive to create and use. You don’t want to create it everytime your application runs. You only want to create it when you need it.

Sure, you could manage all that yourself, but Lazy<T> makes it easy. You just create a lazy wrapper on the expensive object:

Lazy<ExpensiveResource> ownedResource = new Lazy<ExpensiveResource>();

You can simply reference ‘ownedResource.Value’ to get at the expensive object. The first time you access ownedResource.Value, the expensive resource will get allocated, but not before.

Lazy<T> also has a boolean propoerty, named IsValueCreated, that you can check to see if the value has been created. That would be useful when you need to store information from the expensive resource, but only if it’s been used.

Supporting Types without default constructors

Lazy<T> does not enforce the new() constraint. You can use Lazy<T> for types that must be instantiated using a different constructor, or even a factory method. A second constructor specifies a Func<T> that returns the new expensive resource:

Lazy<ExpensiveResource> ownedResource = new Lazy<ExpensiveResource>(

    () => new ExpensiveResource("filename.data"));

You can use this second constructor to better control what code creates the expensive resource. I’ve used a different constructor here, but you could use a factory method, an IOC container, or any method.

We’re living in a Multi Core World

There are two other constructors in Lazy<T>:

public Lazy(bool isThreadSafe);

public Lazy(Func<T> valueFactory, bool isThreadSafe);

These two constructors indicate that you are running in a multi-threaded envrionment, and the lazy construction of of the owned object must be synchronized. (After all, it’s an expensive resource. You don’t want two of them.)

It’s a simple type, but it’s one of those types you’ll find yourself reaching for over and over again.

I’m glad it’s been added.

Ads by Lake Quincy Media

The CodePlex Foundation: Cautiously Optimistic

wwagner — Thu, 17 Sep 2009 15:39:20 GMT

With some fanfare, the CodePlex Foundation launched itself late last week (http://www.codeplex.org). This has generated quite a bit of discussion on blogs, twitter, email lists, podcasts, and everything else.

I’m optimistic, with some reservations about how this will play out.

I’ll preface this discussion with the obvious disclaimer: I am not a lawyer. My knowledge of copyright law comes from asking quite a few questions of editors and attorneys before signing the contracts for the books and articles I’ve written. This is not legal advice. It can’t be because I’m not licensed to practice law.

The Barriers to Open Source Adoption

In my day job, I work with a number of large companies. Many of them have explicit policies against using Open Source code. In addition, some ask for indemnification against IP claims for purchased closed source software. That’s a reasonable action, given the current state of our legal system, the very small number of people that understand software, and the amount of cash that large companies need in order to operate. (It takes a lot of money to make payroll for 100,000 employees).

The probability of using stolen IP is small. That’s why many smaller companies accept that risk (sometimes without thinking). But, the cost of being wrong is very high. Furthermore, because of the way copyright law works, the users of open source software are at risk. If you incorporate stolen IP into your business, it doesn’t matter if you did it knowingly or not, you are at risk of civil penalty.

So imagine you’re the CIO of a big company. You no longer want to spend your days looking at code. You’ve got important meetings to attend. What’s the answer to using Open Source? Do you have someone perform the research and due diligence to satisfy your fiduciary duty? Of course not. You (as CIO) are still responsible. It’s easier to just say no. Sure it costs more money to reinvent something. But it’s legal. Sure it costs more to pick a commercial solution. But you can ask for indemnification in exchange for buying the licenses.

In short, the risk of outsized penalties keeps commercial software developers from benefiting from, and therefore participating in, open source projects.

Purchasing Indemnification

But wait you say. Isn’t Linux used in many large organizations? Certainly. In many of those cases, the large enterprise has purchased the software. Or, more accurately, the company has purchased indemnification against lawsuits. The company providing the software (RedHat, IBM, etc) and the license is accepting the risk, and is using the fees to do what they need to minimize their own risk.

This is pure opinion. I believe that part of Microsoft’s motivation for the CodePlex foundation is to make it easier for large enterprises to use .NET based Open Source projects. Note that many of the Open Source projects in widespread use today are championed by IBM, and run on the Linux Operating System. I believe Microsoft wants to enable the CodePlex Foundation to make a stronger ecosystem for .NET projects. Those .NET projects that are part of the CodePlex Foundation may find better adoption rates at large enterprises.

Copyright Assignment

One of the items on the CodePlex Foundation that is causing lots of concern is the sample license agreement that assigns copyright to the CodePlex Foundation. Here, I’m leaning heavily on my experience with publishers.

First of all, the only way you can assign copyright to another party is if it is yours. OK, that’s obvious, but I think lots of people are missing that. When I sign the contract for a book with a publisher, I do assign the copyright to the publisher (in return for some considerations). The publisher needs me to warrant that the work is *my original work*. The same would be true for Open Source software projects. Hypothetically, for me to assign my OSS project’s copyright, I would have to assert that it’s my original work.

There is another way to assign copyright, which will be necessary for CodePlex and OSS to work. If you ask everyone that contributes to your OSS project to assign the copyright to the project (or you), you do hold the copyright, and therefore you can assign it. (The Apache Foundation Individual Contributor License Agreement contains language necessary to assign the copyright over.)

Note that you can (as the original author) grant a non-exclusive license as an alternative to assigning the copyright. That’s also common in many OSS contributor agreements. I’m not sure how much weight that gives in IP legal entanglements, but it seems to work for the Apache Foundation, and the MySQL organization. I’ll defer to others with more knowledge.

I’d imagine you could grant an exclusive license, but I’ve never seen that.

What the Codeplex Foundation can accomplish

Here’s the funny bit, and why the CodePlex can be a very strong positive force. The originator of a work can’t assign copyright to ‘a project’. Copyright must be assigned to a legal entity. That means a person, a corporation, some other business entity, a non-profit organization, or government entity. The CodePlex foundation is a legal entity, and can be the recipient of a copyright assignment.

The foundation has deeper pockets than most Open Source project leaders I know. I imagine that will continue to be true. The Foundation will, I believe, defend those copyrights that have been assigned to it.

Every book author knows this drill: if your book is successful, websites will spout up that let people download an electronic copy for free. When I find one of those, my only action is to let my publisher know about it. Some of the sites disappear, so it’s clear that the publisher’s attorneys have taken some action. I expect the CodePlex foundation to take similar action (and to take defensive action) when legal issues of IP ownership arise for those patents that have been assigned to it.

My opinion is that the CodePlex Foundation is enabling ownership of copyrights in order to provide an umbrella to protect users of its projects.

Note: I have no idea what, if any, recourse the Foundation, or a project owner, would have regarding a non-exclusive grant of use. See IANAL disclaimer at the beginning of this post.

Why do I care?

We just released an alpha of our first Open Source project (http://elevate.codeplex.com). I didn’t know what to expect. The experience was very positive. I enjoyed the project. I enjoyed the attitude that this project engendered even more.

The most interesting attitude change working with Open Source was that you view the source as the product, rather than the the object code. Often when you’re working, and a ship deadline approaches, you may feel pressure to defer work that isn’t necessary to meet the shipping deliverables. Maybe there’s some refactoring that doesn’t happen. Maybe there are some algorithms that don’t get updated to use a more modern technique. You have to ship, and no one sees the underlying code, so maybe that work gets delayed.

Working on Open Source gives you a different perspective. The source is the product. It must work. That’s necessary, but not sufficient. People are looking at the source in order to evaluate your project. The quality must show in the source, and in the test code. This change in the deliverable manifests itself in a change in our collective attitude toward work. We release in different (smaller) cycles. We focus on the internal source quality as well as the external behavioral quality when we discuss release gates.

That won’t necessarily raise the quality of code. I’ve seen very bad Open Source code. I’ve used closed source products that have excellent quality. And yet, it’s hard to ignore my change in attitude while working. It had the best of both worlds. I enjoyed working on production code (which I don’t get while working on samples for articles and books). I enjoyed creating source that would help other developers learn (like writing books and articles). It really was the best of both worlds.

That makes me interested in working in more Open Source projects. It makes me want Open Source projects to succeed.

How to evaluate the future

One of the most promising aspects of the Soft Launch of the ColdePlex Foundation is that Microsoft has not released this ‘totally baked’. They are openly asking for opinions, participation, and intend to replace the interim board with a permanent (er, permanent for one term. see the bylaws) board. I would expect Microsoft to be represented, but I would not expect them to have a true majority.

I think the board of advisors (or a software due diligence committee) could be more interesting. Somehow, the CodePlex Foundation will need to make a decision on every project that asks to join the foundation. Should it be accepted? One of the most important tasks around that decision is to determine the pedigree of the code that makes up the project. As I said earlier, the probability is small, but the risks are great. One of the greatest services the Foundation could provide would be reference legal documents and accompanying procedures for running a project, accepting patches, and inviting contributors that minimizes the risk associated with IP ownership.

Furthermore, running their organization so that large enterprises feel confident using those projects that are part of the Foundation would be a huge service.

My criteria for measuring the success of the CodePlex Foundation in six months are these:

The community is satisfied with the Foundation’s governance structure.
At least 20 new projects in the CodePlex Foundation.
At least one Fortune 50 company has adopted at least one CodePlex Foundation project.

If the CodePlex Foundation achieves that, I’ll be very happy.

My own Call to Action

I’m excited enough about the CodePlex Foundation to take action. Here’s my TODO list:

Continue to participate in the discussions online, and in any other way that I can.
Start or continue at least one project that gets accepted by the CodePlex Foundation. (I want to experience the process of getting a project accepted by the Foundation first hand.)
Contribute to someone else’s CodePlex Foundation project. (I want to experience how the foundation treats external contributors first hand.)
Convince one customer to use a CodePlex Foundation project. (Yes, this is probably predicated on the previous two items.)

What are you going to do?

Long time, no Euler (or YAEPS # 13)

wwagner — Wed, 26 Aug 2009 03:15:30 GMT

Well, it’s been a long time since I’ve taken the time to solve and blog about one of the Euler problems. It was time to pick this up again.

Problem 13 says:

Work out the first 10 digits of the sum of the following one-hundred 50-digit numbers. <long list of numbers elided>

The key here is that you only need the first 10 digits of the answer. Therefore, you only need to add the first 11 digits for each of the 100 numbers. Here’s why: These numbers do not contain any 0’s in the first position. Therefore, the sum of all the first digits is at least 100. The first digit contributes at least 3 digits in the final answer. Once you get to the 11th digit, that number can’t be great than 900. (100 9’s). It won’t affect anything in the first 10 digits. That’s the end of the work.

That makes the final answer one LINQ query:

   1: static void Main(string[] args)

   2: {

   3:     var finalAnswer = (from index in Enumerable.Range(0, 11)

   4:                        from s in listOfDigits

   5:                        select int.Parse(s[index].ToString()) *

   6:                        (long)Math.Pow(10, 11 - index)).

   7:                        Sum();

   8:     Console.WriteLine(finalAnswer);

   9: }

listOfDigits (elided) is a list of strings where each string contains the digits for one number.

The first line of the query creates an enumeration for the first 11 digits.

The next two lines select a single character from each string, parsing that character to create an integer.

Next, do a little math to move that single digit into the correct column for the sum.

Finally, sum all the integers.

Sweet, huh?

Elevate: SRT Solutions first Open Source Project

wwagner — Wed, 19 Aug 2009 12:29:16 GMT

Chris Marinos started Elevate as a learning time project at SRT Solutions. It’s still very young, but it’s already very useful to me.

Chris wrote a great introductory post on the library, which is hosted on CodePlex.

Elevate contains methods we use, usually based on LINQ queries, or otherwise built on top of the .NET BCL. There are methods to build sequences, sub-divide very large sequences into chunks, perform pattern matching on sequences, and some general purpose composable APIs.

It’s still a very young project, and we’re adding functionality on a regular basis. We’re also actively seeking other community members’ input and contribution. Please visit the project, join and submit ideas. Or, just download it, try it, and suggest ideas on the CodePlex pages.

When Cast doesn’t Cast to T

wwagner — Thu, 23 Jul 2009 03:04:04 GMT

A friend asked me about some issues he was having using Enumerable.Cast<T>(). In his mind, it just wasn’t working. Like so many problems, it was working correctly, just not the way he expected. It’s worth examining.

Examine this class:

   1: public class MyType

   2: {

   3:     public String StringMember { get; set; }

4:

   5:     public static implicit operator String(MyType aString)

   6:     {

   7:         return aString.StringMember;

   8:     }

9:

  10:     public static implicit operator MyType(String aString)

  11:     {

  12:         return new MyType { StringMember = aString };

  13:     }

  14: }

Note: I normally recommend against conversions, (See Item 28 in Effective C#), but that’s the key to this issue.

Consider this code (assume that GetSomeSttrings() returns a sequence of strings)

   1: var answer1 = GetSomeStrings().Cast<MyType>();

   2: try

   3: {

   4:     foreach (var v in answer1)

   5:         Console.WriteLine(v);

   6: }

   7: catch (InvalidCastException)

   8: {

   9:     Console.WriteLine("Cast Failed!");

  10: }

You’d expect that GetSomeStrings().Cast<MyType>() would correctly convert each string to a MyType usingthe implicit conversion operator defined in MyType. It doesn’t, it throws an InvalidCastException.

The above code is equivalent to this construct, using a query expression:

   1: var answer3 = from MyType v in GetSomeStrings()

   2:               select v;

   3: try

   4: {

   5:     foreach (var v in answer3)

   6:         Console.WriteLine(v);

   7: }

   8: catch (InvalidCastException)

   9: {

  10:     Console.WriteLine("Cast failed again");

  11: }

The type declaration on the range variable is converted to a call to Cast<MyType> by the compiler (See Item 36 in More Effective C#). Again, it throws an InvalidCastException.

Here’s one way to restructure the code so that it works:

   1: var answer2 = from v in GetSomeStrings()

   2:               select (MyType)v;

   3: foreach (var v in answer2)

   4:     Console.WriteLine(v);

What’s the difference? The two versions that don’t work use Cast<T>(), and the version that works includes the cast in the lambda used as the argument to Select().

And, that’s where the difference lies.

Cast<T>() Cannot access User Defined Conversions

When the compiler creates IL for Cast<T>, it can only assume the functionality in System.Object. System.Object does not contain any conversion methods, therefore, Cast<T>() does not generate any IL that might call any conversion operators.

Cast<T>() will only succeed if its argument is not derived from the target (or a type that implements the target if the target is an interface), Cast<T> fails.

On the other hand, placing the cast in the lambda for the Select clause enables the compiler to know about the conversion operators in the MyType class. That means in succeeds.

As I’ve pointed out before, I normally view Conversion operators as a code smell. On occasion, they are useful, but often they’ll cause more problems than they are worth. Here, without the conversion operators, no developer would be tempted to write the example code that didn’t work.

Of course, if I’m recommending not to use conversion operators, I should offer an alternative. MyType already contains a read/write property to store the string property, so you can just remove the conversion operators and write either of these constructs:

   1: var answer4 = GetSomeStrings().Select(n => new MyType { StringMember = n });

   2: var answer5 = from v in GetSomeStrings()

   3:               select new MyType { StringMember = v };

Also, if you needed to, you could create a different constructor for MyType.

Will you thrive, or be left behind?

wwagner — Sat, 18 Jul 2009 20:10:13 GMT

A few events recently uncovered a very interesting observation on how developers are hired: the business world often focuses developers toward the exact behavior it claims it doesn’t want. How many times have you heard recently that developers need to have ‘business skills’ and ‘understand the business problem’ and ‘talk to the business side of the house’. I agree that these are important skills for a modern professional developer. However, let’s look at the recruiting process for developers. How much of the developer recruiting process is focused on specific developer tool skills: years of Java, years of ASP.NET, C# and SQL experience, years working with Oracle, or whatever tool is needed in the job description. Really smart developers without those skills will lose out on an opportunity early in the screening process. That’s because they have the relevant business knowledge, and the relevant software construction knowledge, but not the latest buzzwords in the resumes.

Immediately, the law of unintended consequences starts to rear its ugly head because of this phenomena. Developers know this is how the recruiting project works. Their next job relies on their ability to gain relevant tooling experience with modern software construction tools. With that kind of motivation, it should not surprise any manager that her developers crave knowledge and experience with modern tools above any other relevant business experience.

In fact, I think that the business world gets the very developers they deserve. Companies that recruit based on buzzwords will get developers that intend to advance their careers by padding their resumes with buzzwords. Companies that look for developers that can think, analyze problems, and deliver software that solves real problems will find those developers.

Aligning your skills to your goals

What kind of developer do you want to be? And, equally important, what do you view as your contribution to your company? Is it a set of buzzwords or is it something greater?

One resource to help you find your way is Thrive, Microsoft’s new site for developers dedicated to advancing their career. This is a site with content from folks inside and outside Microsoft that have important advice and resources that can help you advance your career, even in the current economy.

There’s information on learning specific tech skills, growing your non-tech skills and helping to highlight them, and how to connect with your community. It’s certainly worth frequent visits.

And, remember to highlight the skills that make you most valuable.

Book Review: Essential LINQ

wwagner — Mon, 13 Jul 2009 15:08:52 GMT

During my recent vacation, I read the final print version of Essential LINQ, by Charlie Calvert and Dinesh Kulkarni.

Normally, I try to answer the question, “Who should read this book?” That answer eluded me on this book, due to the thorough treatment Charlie and Dinesh give the subject. Essential LINQ is approachable by developers that have minimal experience with LINQ, and yet those developers that have been using LINQ since day one will learn something from this book.

The Essence of LINQ and LINQ Patterns and Practices

Everyone will learn something from two chapters in this book. “The Essence of LINQ” describes the principles behind the LINQ libraries and language enhancements. By understanding the goals of LINQ, you’ll immediately gain insight that will make LINQ more approachable and more productive for you.

In chapter 16, toward the end of book, Charlie and Dinesh discuss some patterns you’ll run into while developing with LINQ. You’ll learn how to use LINQ to SQL entities as part of a large multi-tier application. You’ll learn how to improve performance in LINQ applications. You’ll learn how to separate concerns in LINQ based applicaitons. LINQ is too new to be considered complete in terms of ‘best practices’, and thankfully neither Charlie nor Dinesh approach this subject with that kind of arrogance. Instead, they offer their recommendations, and invite discussion on the subject.

A catalog of LINQ Functionality

Throughout the rest of the book, Charlie and Dinesh explain LINQ to Objects and LINQ to SQL from a usage standpoint, and from an internal design standpoint. In other chapters, LINQ to XML is discussed. The authors provide examples of transforming data between XML and relational storage models as well. In every section, they tie together those features with the concepts discussed in “The Essence of LINQ”. That continuity helps to reinforce your understanding of LINQ through its design concepts.

After reading this book, you’ll be able to leverage LINQ in all your regular coding tasks. You’ll have a much better understanding of how LINQ works, and when you’ll encounter subtle differences in how different LINQ providers may behave.

LINQ to SQL vs. Entity Framework

It seems you can’t discuss LINQ without at least wading into the controversy of LINQ to SQL vs. Entity Framework. This book wades there as well (It was finished about the time the first EF release was made). More time is spent on LINQ to SQL, as it is more approachable from an internal design perspective. However, the chapters that cover EF build on that knowledge to help you understand how the two database LINQ technologies are more complementary adversarial. In addition, they touch on when you should consider one over the other in your application.

A look at providers

This section is the least complete, but the most useful to look into the future of the LINQ universe. It’s too easy to view LINQ as LINQ to Objects, LINQ to SQL, and LINQ to XML, and nothing more. This chapter gives you a brief view some of the other providers people have created for other types of data stores. Looking at some of those providers (especially the IQToolkit) will give you a greater appreciation for how LINQ can be used with a wider variety of data sources than you ever imagined.

So, is this book for you?

If you are interested in being more productive with LINQ, you should read this book. You’ll probably thumb through it again and again as you search for better ways to solve different problems.

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.