jeffbarnes.net

Alabama Code Camp - January 17th

jeff.barnes — Sun, 04 Jan 2009 06:49:06 GMT

It's that time again. The next Alabama Code Camp has been scheduled for Saturday, January 17th in Montgomery, AL at the Auburn University campus. The call for speakers is now open. Please stay tuned to the web site for additional information. The event is barely two weeks away. So, registration will probably open soon.

This should be a good opportunity to learn some new things and meet some new people. I hope to see you at the event.

MSDN Developer Conference

jeff.barnes — Tue, 18 Nov 2008 14:31:17 GMT

For those of you that haven’t heard, Microsoft has recently announced the MSDN Developer Conference, which is a one day event that delivers that core content from the PDC. So, if you didn’t get to make it out to Los Angeles for PDC 2008, this will be your chance to get to see some of the primary content. The event will be held at several cities across the U.S. over the next couple of months. The fee is $99, which is quite reasonable.

On Tuesday, December 16th, I will be speaking at the Atlanta event. I will be co-presenting with Chad Brooks for the “Lap Around Windows Azure and the Azure Service Platform” session. Glen Gordon recently blogged about several perks for attending the conference including a lot of nice giveaways. If you are interested in keeping up with the future of the Microsoft .NET platform and peripheral technologies, you should make time to attend.

I hope to see you at the event.

Thoughts on PDC 2008 Keynote

jeff.barnes — Mon, 27 Oct 2008 16:52:27 GMT

Microsoft formally kicked off the PDC event this week with Ray Ozzie delivering the keynote address. I was fortunate enough to land a seat on the front row. As expected, some new initiatives were finally unveiled: Windows Azure. Azure is the new cloud services platform, which has an extremely compelling story. Essentially, this is an effort to push the hosting of application from inside the enterprise to the cloud. Don't be fooled into thinking that this is only referring to web applications. Azure expands well beyond the scope of mere web applications. It will offer a platform for inexpensively hosting applications, databases, and more.

Based on what has been shown so far, it appears to be a very simple and seamless development experience. Developers are still capable of locally developing and debugging applications on their desktop. After the solution is ready to be deployed, you merely have to go to the Azure portal to create an application environment and upload the solution as a package.

Where all of this stuff starts to get interesting is the scalability aspect. So, you need to scale your application up for an increased number of users? No problem. All you need to do is modify your configuration to specify a higher number of nodes. Azure takes care of all of the dirty work behind the scenes. It will be interesting to see whether all of this works as well as advertised. If it pans out, I can see this as being overwhelmingly compelling for small companies all the way to large enterprises. Imagine not only the cost savings, but the how much easier it would be to avoid the headaches of setting up your own major infrastructure in house.

However, I still think trust is going to be a major factor. There are many businesses that are understandably reluctant to let someone else house their data. It will take some time to build up trust and convince many organizations that this is a viable option. However, I am starting to believe that the cost savings could be a compelling argument to give it a try. Nevertheless, security will be a concern at the forefront of this platform. I am anxious to hear more about the security aspects of the platform later this week. More importantly,I am incredibly eager to get my hands on the CTP and give it a test drive.

What do you think? I'd love to hear the comments of others.

Next TechMixer Scheduled for Nov 13th

jeff.barnes — Tue, 21 Oct 2008 05:01:00 GMT

For those technology professionals in Birmingham and surrounding areas, take note that the next TechMixer has been scheduled for Thursday, November 13th. It will be held at the Innovation Depot from 5:30 PM to 8:30 PM.

In case you aren't familiar with it, this is one of the area's largest technical networking events. There will be booths to represent all of the area user groups as well as several technical companies. Each iteration of the event has turned out a larger and larger crowd. There is usually free finger foods as well as a cash bar. So, load up on business cards and come on out to meet some new people.

Be sure to visit the registration site and RSVP.

PDC 2008 Is Approaching

jeff.barnes — Mon, 20 Oct 2008 21:14:00 GMT

It is getting close to time for PDC, and I have been giving some thought to the sessions that I want to attend. There are too many scheduling conflicts to make all of the ones that interest me. So, I have tried to strike a balance between my focus areas and some things a little outside of my comfort zone. Given the breadth of the technologies that will be presented, I wanted to get a broad mix to try and understand the vision of where things are going over the next year or two. Considering all of the pending announcements, it is certainly promising to be a very exciting week.

For those that are interested, I will be blogging and using twitter quite a bit for the duration of the event. If you want to meet up and talk tech for a while, feel free to ping me. Here is my tentative schedule of sessions that I plan to attend, but it is certainly subject to change.

Sunday, October 26

Sunday Evening

Party with Palermo

Monday, October 27

8:30 AM - 10:30 AM

8:30 AM - 11:00 AM

Keynote

11:00 AM - 12:15 PM

Under the Hood: Advances in the .NET Type System

151

12:45 PM - 1:30 PM

Microsoft Expression Blend: Tips & Tricks

408B

1:45 PM - 3:00 PM

Microsoft Visual Studio: Bringing out the Best in Multicore Systems

502A

3:30 PM - 4:45 PM

ASP.NET MVC: A New Framework for Building Web Applications

153

5:15 PM - 6:30 PM

WF 4.0: A First Look

151

Tuesday, October 28

8:30 AM - 10:30 AM

8:30 AM - 11:00 AM

Keynote

11:00 AM - 12:00 PM

Keynote

11:00 AM - 12:30 PM

12:45 PM - 1:30 PM

WCF: Zen of Performance and Scale

515B

1:45 PM - 3:00 PM

SQL Server 2008: Beyond Relational

406A

3:30 PM - 4:45 PM

Microsoft Silverlight Futures: Building Business Focused Applications

153

5:15 PM - 6:30 PM

Entity Framework Futures

151

Wednesday, October 29

8:30 AM - 10:00 AM

8:30 AM - 11:00 AM

Keynote

10:30 AM - 11:45 AM

WCF 4.0: Building WCF Services with WF in Microsoft .NET 4.0

151

12:00 PM - 12:45 PM

Improving Code Quality with Code Analysis

409A

1:15 PM - 2:30 PM

Modeling Data for Efficient Access at Scale

403AB

3:00 PM - 4:15 PM

The Future of C#

502A

4:45 PM - 6:00 PM

WF 4.0: Extending with Custom Activities

408B

Thursday, October 30

8:30 AM - 10:00 AM

Parallel Symposium: Addressing the Hard Problems with Concurrency

515A

8:30 AM - 9:45 AM

10:15 AM - 11:30 AM

Microsoft .NET Framework: CLR Futures

153

10:15 AM - 11:45 AM

12:00 PM - 1:15 PM

"Oslo": Building Textual DSLs

502A

12:00 PM - 1:30 PM

1:45 PM - 3:00 PM

An Introduction to Microsoft F#

502A

MVP++

jeff.barnes — Wed, 01 Oct 2008 14:58:00 GMT

I was just informed that I have been awarded again as an MVP for 2009 in Connected Systems. This is something that I certainly regard as an honor considering the extent of distinguished talent in the ranks of the MVP program.

It is going to be an exciting year for Connected Systems with Oslo around the corner among many other advancements in areas such as BizTalk, WCF, and WF. Even outside of Connected Systems, there is a plethora of interesting topics: Visual Studio 2010, .NET Framework 4.0, F#, Parallel LINQ, Iron Ruby, Iron Python, etc.

It is an exciting time to be a developer on the Microsoft platform, and I am honored to be in a privileged position where I can leverage additional resources to engage and assist the community.

EntLib 4.0 Presentation Materials

jeff.barnes — Thu, 25 Sep 2008 09:15:03 GMT

It took me a lot longer than expected to post this material. I am beyond overloaded between work and personal stuff that is going on right now. At any rate, the presentation slides and code can be downloaded here.

Keep in mind that the code requires Enterprise Library 4.0 to be installed, which can be downloaded from CodePlex at the following link: http://www.codeplex.com/entlib. Be sure to look at the QuickStart sample projects that are installed with the library. A couple of them are the ones we looked at during the presentation. These are a great guide to getting started and learning more about the features.

You should also check out the community project: http://www.codeplex.com/entlibcontrib.

Presenting for BSDA on Thu Sept 11

jeff.barnes — Tue, 09 Sep 2008 02:10:20 GMT

I meant to blog about this last month, and it completely slipped my mind. On Thursday, September 11, I will be presented for the Birmingham Software Developer Association. The meeting will convene at 6:30 PM at New Horizons. I will be delivering a presentation that provides an overview of the major features in Enterprise Library 4.0. Obviously, due to the breadth of functionality, this will be a high level survey that only gives a teaser of what Enterprise Library has to offer.

Here is the abstract:

Enterprise Library is a collection of application blocks provided by the Microsoft Patterns & Practice Team. These application blocks are essentially "infrastructure modules" that can be used "as is", extended, or modified to assist with solving common development challenges such as database access, logging, validation, and more. In this presentation, we will survey the major features that Enterprise Library has to offer by taking a look at both pros and cons of the most commonly used application blocks.

TechMixer University WCF Presentation Material

jeff.barnes — Wed, 20 Aug 2008 10:41:01 GMT

Yesterday, the first ever TechMixer University was held at the BJCC. Hats off to the organizers of the event. It seemed to be very well planned and coordinated. Everyone that I spoke with was enjoying themselves. I hope there will be more of these events in the future. They are great for building the overall technical community in the Birmingham area.

Right after lunch, I gave a presentation entitled "Hit the Ground Running with WCF Services." It was an introduction to some of the core concepts in WCF. Based on a rough estimate, I would say about 40 or so were in the session. I greatly appreciate the feedback that I received from several attendees. Hopefully, it will ease the learning curve for some of you.

As promised, I have posted the slides and code for my presentation. You can download it here. If you have any questions, feel free to ping me at jeff _ at_ jeffbarnes.net.

Sara Ford Presenting in Birmingham on 8/25

jeff.barnes — Mon, 11 Aug 2008 21:04:12 GMT

There will be a special presentation by Sara Ford on Monday, August 25th about Visual Studio IDE Tips and Tricks. For those of you that don’t know, Sara Ford maintains the popular blog Visual Studio Tip of the Day and works on the CodePlex team. She will be passing through the Birmingham, AL area after the DevLink event and has graciously agreed to drop by and give a talk to the area. It will be held at the Southern Living Auditorium on the Southern Progress Campus located at 2100 Lakeshore Drive. Here is a link to the event registration with complete details: https://www.clicktoattend.com/invitation.aspx?code=130429

Those of you that know me are already aware how I am a big advocate of time savers in the IDE. This will be a great opportunity to learn a few things to add to your bag of tricks for getting things done in Visual Studio. I hope to see you there!

Here is the abstract for the presentation:

Performance improvements begin by speeding up the simple task you do every minute of every hour of every day you use Visual Studio. Just like a coin jar where you place your spare change, you’ll see the time you save add up into the days, weeks, and into the months. This talk provides the best of the best, 21 tips that can be used in any language, which stretched across your 3 primary activities in the IDE: coding, customizing, and debugging.

Sara Ford is the program manager for CodePlex, Microsoft’s open source project hosting site. Prior to CodePlex, she worked on the Visual Studio team for six years, where she continues to run the Visual Studio Tip of the Day on her blog. Her life-long goal is to become a 97 year old weightlifter, so she can be featured on the local news.

TechMixer University – August 19th

jeff.barnes — Mon, 11 Aug 2008 20:46:46 GMT

On Tuesday, August 19th, TechMixer University will be held in Birmingham, AL. This will be a large community driven training event that covers a wide spectrum of technologies. The organizers have strived to offer a little something for everyone including developers, database professionals, project managers, and network professionals. The event also provides coverage of non-Microsoft technologies such as Oracle, MySql, and Ruby.

Even if you can’t attend the entire event, I would encourage you to drop by for one or two sessions that interest you. Visit the website for complete details: http://www.techmixeruniversity.com/TechMixer_University.html

I’ll be delivering a session on WCF entitled “Hit the Ground Running with WCF Services”. Here is the abstract:

Windows Communication Foundation (WCF) is a major advancement within the Microsoft .NET platform that allows for easily exposing units of functionality as services that are accessible via a broad spectrum of communication protocols. WCF has been built from the ground up around a highly flexible and extensible model that allows developers to concentrate on business problems rather than the details of communication plumbing. Write your business logic once and simply expose it over the necessary protocols via configuration without changing a line of code! If this sounds interesting, please join me for a crash course in the fundamental concepts of WCF. This session is packed with material and strives to significantly reduce the learning curve for those that are new to the technology by providing an introduction to major features and capabilities of the WCF platform.

VS2008 and .NET 3.5 SP1

jeff.barnes — Mon, 12 May 2008 21:29:12 GMT

In case you haven't heard, Microsoft has formally announced plans to provide a service pack (SP1) for Visual Studio 2008 and .NET Framework 3.5 by the end of the year. There is a long list of items that will be included, but the most notable one to me was the ADO.NET Entity Framework.

I'll avoid repeating all of the information here. My intent was to simply help propagate the information to the masses. For all of the details, go read Brad Abrams' extensive blog post about the framework portion of the news. The WebDev Tools Blog also has a long blog post that details more of the Visual Studio portion of the release. You should also listen to the latest episode of Dot Net Rocks (Show #340). Carl Franklin and Richard Campbell interviewed Brad and Omar Khan about a lot of the details.

Over the next few months, I will be closely following this release and tinkering with the betas as much as possible. Once EF is officially released, I'm hoping to get it into my production environment as soon as possible.

It is an exciting time to be a .NET developer!

BizTalk Server 2006 R3 Announced

jeff.barnes — Thu, 24 Apr 2008 12:07:38 GMT

In case you haven't heard, it was formally announced that a new release of BizTalk Server 2006 is being planned to provide better support for Windows Server 2008, SQL Server 2008, and .NET Framework 3.5.

Here are the major highlights:

New web service registry capabilities with support for UDDI (Universal Description Discovery and Integration) version 3.0
Enhanced service enablement of applications (through new and enhanced adapters for LOB applications, databases, and legacy/host systems)
Enhanced service enablement of “edge” devices through BizTalk RFID Mobile
Enhanced interoperability and connectivity support for B2B protocols (like SWIFT, EDI, etc)
SOA patterns and best practices guidance to assist our customer’s implementations

The major goodness will still have to wait for Oslo. :)

MVP Summit Next Week

jeff.barnes — Wed, 09 Apr 2008 10:27:48 GMT

Next week, the annual Microsoft MVP Summit will be held in Seattle. The event runs for four days and will be split between the Washington Convention Center and Microsoft's campus in Redmond. The majority of my focus will be on Oslo. At this point, I'm not sure how much of the information will be subject to NDA, but I will definitely pass along any interesting tidbits that are eligible for disclosure.

If nothing else, I'm sure that I will be twittering a lot during the week. So, you can follow along with what's happening via my twitter feed: http://twitter.com/jeff_barnes. I'm looking forward to the opportunity to hang out and speak geek with a number of other MVPs and Microsoft employees. It has been far too long since I have spoken with a number of those guys due to my crazy workload over the last couple of months.

To StringBuilder Or Not To StringBuilder

jeff.barnes — Tue, 18 Mar 2008 05:14:15 GMT

Between work and stuff going on in my personal life, there hasn't been a lot of spare time for blogging and developer community things over the last few weeks. Hopefully, that will be changing in the near future. In the meantime, I wanted to squeeze in a quick blog post about something that came up today regarding StringBuilder.

It was pointed out someone on my team was concatenating several strings to build a query in a few methods. It is arguable whether these particular queries should be embedded in the source code, but that isn't what this post is about. It was requested that the developer modify the source code to use a StringBuilder rather than concatenating the strings. Generally speaking, I would agree with this approach as the StringBuilder is more efficient when concatenating several strings, but this wasn't one of those cases.

Consider the following two methods:

public static string LiteralConcatenationExample()
{
    return "SELECT T1.Field1, " +
                  "T1.Field2, " +
                  "T1.Field3, " +
                  "T2.Field4 " +
            "FROM Table1 T1 " +
            "INNER JOIN Table2 T2 ON T1.Field1 = T2.Field1";
}

public static string StringBuilderWithLiteralsExample()
{
    StringBuilder sb = new StringBuilder();

    sb.Append("SELECT T1.Field1, ");
    sb.Append("T1.Field2, ");
    sb.Append("T1.Field3, ");
    sb.Append("T2.Field4 ");
    sb.Append("FROM Table1 T1 ");
    sb.Append("INNER JOIN Table2 T2 ON T1.Field1 = T2.Field1");

    return sb.ToString();
}

Which method do you think would be more efficient?

If you chose the second method, you should take a closer look at the generated IL:

.method public hidebysig static string  LiteralConcatenationExample() cil managed
{
  // Code size       11 (0xb)
  .maxstack  1
  .locals init ([0] string CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldstr      "SELECT T1.Field1, T1.Field2, T1.Field3, T2.Field4 "
  + "FROM Table1 T1 INNER JOIN Table2 T2 ON T1.Field1 = T2.Field1"
  IL_0006:  stloc.0
  IL_0007:  br.s       IL_0009
  IL_0009:  ldloc.0
  IL_000a:  ret
} // end of method Program::LiteralConcatenationExample

.method public hidebysig static string  StringBuilderWithLiteralsExample() cil managed
{
  // Code size       90 (0x5a)
  .maxstack  2
  .locals init ([0] class [mscorlib]System.Text.StringBuilder sb,
           [1] string CS$1$0000)
  IL_0000:  nop
  IL_0001:  newobj     instance void [mscorlib]System.Text.StringBuilder::.ctor()
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  ldstr      "SELECT T1.Field1, "
  IL_000d:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_0012:  pop
  IL_0013:  ldloc.0
  IL_0014:  ldstr      "T1.Field2, "
  IL_0019:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_001e:  pop
  IL_001f:  ldloc.0
  IL_0020:  ldstr      "T1.Field3, "
  IL_0025:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_002a:  pop
  IL_002b:  ldloc.0
  IL_002c:  ldstr      "T2.Field4 "
  IL_0031:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_0036:  pop
  IL_0037:  ldloc.0
  IL_0038:  ldstr      "FROM Table1 T1 "
  IL_003d:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_0042:  pop
  IL_0043:  ldloc.0
  IL_0044:  ldstr      "INNER JOIN Table2 T2 ON T1.Field1 = T2.Field1"
  IL_0049:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_004e:  pop
  IL_004f:  ldloc.0
  IL_0050:  callvirt   instance string [mscorlib]System.Object::ToString()
  IL_0055:  stloc.1
  IL_0056:  br.s       IL_0058
  IL_0058:  ldloc.1
  IL_0059:  ret
} // end of method Program::StringBuilderWithLiteralsExample

As you can see, the string concatenation is considerable more efficient. This may be a bit confusing to some people as you have undoubtedly had it hammered into your head that a StringBuilder should be used when concatenating strings. Well, I would agree when you are dealing with dynamic strings that are built using parameters. However, literal strings are a different story.

Since this scenario is using literal strings, the compiler can optimize the values into one large string that can be loaded with a single load string operation (ldstr). If the code is modified to use a StringBuilder for each line of the query, it actually increases the number of operations by four for each line of the query.

In fairness, most situations will probably be dealing with dynamic strings, which would change this scenario back to favor the usage of a StringBuilder. However, you should keep in mind that a StringBuilder doesn't automagically give you a more efficient solution in every situation, especially if you are only concatenating a few strings.

Dell XPS M1530 - Finally Loaded and Ready

jeff.barnes — Wed, 12 Mar 2008 12:20:59 GMT

The last time that I purchased a computer was 2003. I bought all the parts and built my own gargantuan desktop, which has been my faithful servant for the nearly five years. Unfortunately, all good things must come to an end. Although my old desktop would still get the job done, it was becoming noticeably outdated. During the last few years, I have also found myself becoming more and more dependent upon the need for a laptop. It is a little difficult to drag around a mammoth desktop to code camps and user groups when I'm doing a presentation. While my employer issued laptop was adequate, it certainly left a lot to be desired.

After debating for some time as to whether I wanted another desktop or a kick ass laptop, I finally decided it was time to say good bye to my desktop. It is difficult for me to come up with many valid reasons for going the desktop route again. Five years ago, I was a fairly intense MMORPG gamer, but I have finally beaten that addiction and have no desire to return to such a waste of time (albeit a fun waste of time). My gaming itch is now satisfied via XBox 360. Games that can be paused are much more attractive to me these days. Since PC gaming is removed from the picture, a laptop was the logical choice.

After researching quite a few options and waiting for the right deal to come along, I finally went with the Dell XPS M1530. It was the perfect balance between price and power. I have spent many hours over the last several nights trying to get it setup with all of my software and various tweaks. Finally, it is beginning to feel like home rather than a stranger's computer.

Here is a photo of the model that I bought as well as the specs:

Intel Core 2 Duo Processor T7500 (2.2Ghz / 800Mhz FSB / 4MB L2 Cache)
4GB DDR2 667Mhz
200GB 7200RPM SATA (with Free Fall Sensor)
256MB NVIDIA GeForce 8600M GT
8X DVD+/-RW Slot Load Drive
Intel 4965AGN Wireless N Mini-Card
85 WHr 9-cell Lithium Ion Primary Battery
Integrated Biometric Finger Print Reader
Integrated Web Camera

As I write this post, my old desktop is being reformatted and reinstalled with Windows Server 2003. It will now become a file server for my wife and me, and it will probably serve a few other experimental purposes as well. I would love to have loaded Windows Server 2008 on it, but the hardware isn't 64 bit. At least, my old companion will continue to live on in some other capacity rather than being sent to the big hardware dumpster in the sky.

WCF 3.5: Syndication Feeds

jeff.barnes — Tue, 04 Mar 2008 11:09:39 GMT

In .NET 3.0, WCF did not have any built-in support for syndication feeds, such as RSS and ATOM. As a result, it was necessary to roll your own solution anytime you wanted to render a syndication feed from your service. While this wasn't an incredibly difficult task, it was still rather tedious. Fortunately, .NET 3.5 introduced rich support for easily enabling syndication feeds from your service with relatively little effort. Overall, it does a great job of handling the dirty work for you. Let's take a look at how to set it up.

For this example, let's say that you have a WCF service that provides product information. We want to enhance this service to provide an RSS/ATOM feed containing the product information. The first thing we need to do is setup our service contract.

[ServiceContract(Namespace = "JeffBarnes.Samples.Syndication")]
[ServiceKnownType(typeof(Rss20FeedFormatter))]
[ServiceKnownType(typeof(Atom10FeedFormatter))]
public interface IProductService
{
    [OperationContract]
    [WebGet(UriTemplate = "/product/{code}")]
    Product GetProduct(string code);

    [OperationContract(Name = "GetAllProducts")]
    [WebGet(UriTemplate = "/products?format={format}")]
    SyndicationFeedFormatter GetProductSyndicationFeed(string format);

    [OperationContract(Name = "GetProductsByCategory")]
    [WebGet(UriTemplate = "/products/{category}?format={format}")]
    SyndicationFeedFormatter GetProductSyndicationFeed(string category, string format);
}

If you are familiar with WCF services, the ServiceContract and OperationContract attributes should already be familiar to you. Depending upon whether you have written many advanced services, you may also be familiar with ServiceKnownType. If not, it is essentially used to inform the WCF runtime that it needs to be aware of a specific type for the purpose of serialization.

The WebGet attribute is a newcomer in .NET 3.5. It is part of the new REST stack. I have already written about WebGet in a previous post. You should refer to it for a more thorough overview. The abridged version is that it allows the WCF runtime to dispatch HTTP GET requests that match the specified UriTemplate to the given method. As you can probably discern from the code, the GetProductSyndicationFeed method returns a feed of products in a specified format (RSS or ATOM).

So, what does the implementation look like? I'm going to trim it down to the most interesting pieces for the sake of brevity.

// Create the syndication items from the products.
IEnumerable<SyndicationItem> items =
    from product in products
    orderby product.Code
    select new SyndicationItem(...);

// Create the syndication feed.
SyndicationFeed feed = new SyndicationFeed(
    "Jeff's Product Catalog",
    feedDesc,
    WebOperationContext.Current.IncomingRequest.UriTemplateMatch.RequestUri,
    items);

// Determine the format to use.
SyndicationFeedFormatter formatter = null;
if (String.Compare(format, "rss", true) == 0)
{
    formatter = new Rss20FeedFormatter(feed);
}
else
{
    formatter = new Atom10FeedFormatter(feed);
}

return formatter;

First, a LINQ query is used to construct an enumerable collection of SyndicationItems based upon the product information. SyndicationItem offers a lot of flexibility and extensibility. It provides seamless support for formatting your content as html, xml, or custom formats. Next, the SyndicationItems are supplied to a SyndicationFeed that decorates the items with some other information. Ultimately, the SyndicationFeed is wrapped by a feed formatter. Depending upon the requested format, either RSS or ATOM will be used.

There is one last gotcha to keep in mind in regards to the hosting of the service. In order to enable the REST stack, there is a specific binding and behavior that must be used: webHttpBinding and webHttpBehavior. You can manually set these up via configuration. However, there is a new ServiceHost subclass available that offers a configuration free alternative. Check out the following snippet:

using (WebServiceHost host = new WebServiceHost(typeof(ProductService), new Uri("http://localhost:8000/ProductService")))
{
    host.Open();
    Console.WriteLine("Service Ready");
    Console.Read();
}

WebServiceHost will automatically create an endpoint with the necessary binding and behavior to enable the REST stack. I don't even have a configuration file in this demo. The only configuration code is what is shown above. If you are using IIS to host your service, you can still use WebServiceHost, but it requires referencing System.ServiceModel.Activation.WebServiceHostFactory from your SVC file.

Once you get everything wired together, it's as easy as typing a URL into your web browser of choice and viewing the results. Most browsers are aware of syndication feeds and apply special formatting to them. For example, here is a screen shot of IE when you hit http://localhost:8000/productservice/products/Beverage for the demo.

I have barely scratched the surface of the capabilities of the syndication infrastructure in WCF, but this example effectively demonstrates how little effort is required to get started. I'll probably do some additional posts on some of the more advanced syndication abilities at some point in the future.

You can download the complete sample here.

Return to Twitter

jeff.barnes — Tue, 26 Feb 2008 14:36:56 GMT

Due to the persistence of Keith Elder, he has managed to convince several of the speakers at Alabama Code Camp to either sign up for Twitter or start using it again. Some of the suckers that fell into the trap include Robert Cain (Arcane Code), Todd Miranda, and Doug Turnure.

Several months ago, I signed up for Twitter and managed to stick with it for a little while, but it became too much effort. One of the biggest gripes that I had with it was the limited abilities to send updates. At the time, you were restricted to the web site or text messages from your phone. Personally, I'm not a huge fan of text messaging, especially when I'm sitting at the computer. There was supposedly an IM interface, but it never worked.

Fast forward to present day and it appears as though their web site has been greatly improved. Twitter has opened up some web services that have enabled a number of custom clients to be created. Keith was a big advocate of Witty, which is a WPF smart client. (What a shocker...Keith evangelizing a smart client application). After getting it downloaded and setup, I have to admit that it is quite nice. The application has that smooth WPF look and it appears to be fairly responsive.

So, I have made my return to Twitter. For the last couple of days, I have been sending periodic updates. Admittedly, I can feel it becoming somewhat addictive. When there is a moron at the office causing the day to suck tremendously, it provides a nice little outlet to let everyone know about it. If you are interested in ~~following~~ stalking me, here is the link to my twitter feed: http://twitter.com/jeff_barnes.

Alabama Code Camp Presentations

jeff.barnes — Mon, 25 Feb 2008 12:07:46 GMT

I decided to take a couple of nights to catch up on sleep. So, I'm a little late about posting a follow up about code camp. At any rate, another code camp has come and gone. In my opinion, the event was enormously successful. It appeared to be one of the largest crowds to date for the Alabama Code Camp series. Registration prior to the event was closed after 200 people, and I would be willing to wager at least 150 or more of them showed up on Saturday.

For the most part, I felt as though my sessions went well. I would have to say my classic "Introduction to WCF" presentation was my best of the day. The room was packed out and most of the attendees seemed to be engaged and interested. If it hadn't been for a few slots that needed to be filled, I probably wouldn't have even given the introductory talk. But, I'm glad that I did. It goes to show that there are still a lot of folks unacquainted with WCF or were looking for a refresher. I'll be sure to submit this one again at future events.

My talk on REST vs SOAP from a WCF perspective also went relatively well. However, the 45 minute limit on the session really caused me some grief. During my rehearsal of the presentation, I felt pretty good about the layout in regards to time, but it didn't pan out so well for the real deal. I ended up having to rush through a lot of the code at the end.

The parallel programming talk was easily my worst of the day, but I appreciate those who told me they enjoyed the material. It was definitely an experimental presentation, and I probably kept it at too high level. As I was preparing the material, I restructured it several times and never reached a point where I was completely happy with it. Given the wide range of experience and backgrounds of individuals attending code camp, it was difficult to decide which group to target. At any rate, I appreciate the attendees allowing me to use them for a trial run. I will definitely be giving this presentation again, but it will be dramatically different. Most likely, it will become a two part presentation. The first one will be mostly conceptual with adequate code to reinforce the concepts and the second part will jump right into the nuts and bolts of Parallel LINQ.

Here are the downloads for each presentation. Each zip file contains both the presentations and the demos.

Introduction to Parallel Programming
Introduction to Windows Communication Foundation
REST vs SOAP: Is There Really A Winner (WCF's Perspective)

SOA Society Meeting - Feb 26th

jeff.barnes — Thu, 21 Feb 2008 20:57:16 GMT

Below is the announcement for the February Meeting of the SOA Society...

After exploring domain-specific modeling at the January meeting, the SOA Society is going to look at service-oriented architecture in the context of the Business Services Model at the February meeting. Marc Guthrie, the CEO of COMFRAME, will present, “ SOA – The Perfect Storm”.

According to Guthrie, “How parallel progressions in Information systems complexity, business knowledge requirements, and technology /standards advancements has created the perfect environment for the business services model.”

Join us Tuesday and hear about the forces that are driving the next wave of technology innovation. The meeting is as usual free but please R.S.V.P. The January meeting was a packed house. We want to be sure that there will be pizza enough to go around.

Meeting Date: Tuesday February 26, 2008
Meeting Time: Gather at 6:00 PM, Presentation @ 7:00 P.M.
Place: Intermark Group, 1800 International Park Drive, Suite 500 (off Acton Road, near the Acton Road Exit off I-459); Birmingham, AL 35243 [Directions 1800 International Park Drive]
Host: Scott Pierce
Coordinator: Margaret Marston
Refreshments: Pizza
Meeting Fee: FREE
RSVP: Margaret Marston [mmarston@windstream.net]

Getting Started with PLINQ

jeff.barnes — Tue, 12 Feb 2008 07:51:55 GMT

Going forward, I am hoping to write at least one post per week about PLINQ. Since this is really the first one, it seemed like a good starting point would be going over how to get setup with the bits. Keep in mind that PLINQ is currently available as a CTP. The most recent version is the December 2007 CTP. Although I haven't experienced any problems, you should remember that it is still in a pre-release status. In other words, don't go installing it onto critical environments.

You can download the CTP here. It should be noted that PLINQ requires .NET Framework 3.5 and Visual Studio 2008. Windows Server 2003, XP, and Vista are the only supported OSes. Hopefully, you aren't trying to install it on Windows 95 or you have bigger problems. There are two files to download: ParallelExtensions.zip and ParallelExtensions_Dec07CTP.msi. Obviously, the msi file will install the bits on your machine. The zip file contains the API documentation.

Before you even open up Visual Studio, I strongly recommend reading through the API documentation. It also contains an overview of the different ways to leverage PLINQ as well as some of the concepts behind it. There isn't a huge amount of information, but it is a good primer that helps point you in the right direction. I think it is rather commendable of the Parallel Programming Team to provide this type of documentation with their first CTP. I have worked with some CTPs that didn't give you anything to go on in terms of documentation.

When you get ready to fire up Visual Studio, you will need to add a reference to the System.Threading assembly. After your reference is added, the fun stuff is contained within System.Linq, System.Linq.Parallel, and System.Threading. You may find it helpful to peruse the assembly with Reflector to get an idea of the classes and their relationships.

Enjoy!

My Technical Focus Areas for 2008

jeff.barnes — Tue, 12 Feb 2008 04:38:55 GMT

When it comes to my list of favorite technologies, it is no surprise to find WCF at the top of the list. Ever since I first experimented with the bits of the early CTPs, I have been an avid supporter of the platform. The design is so flexible and extensible that I suspect it will continue to be the communication goo of Microsoft .NET solutions for a number of years. While I have no intentions of abandoning WCF, I have been feeling a desire to branch out a bit into some other areas. After giving it quite a bit of thought, I have decided that I am going to focus my research/learning efforts in the following areas for 2008:

Oslo
In case you haven't heard, Oslo is the codename for a concerted effort by the Microsoft Connected Systems Division to unify some of their products into a complete SOA platform. For the most part, it will be manifested in the next major version of BizTalk, Visual Studio, and .NET Framework. However, I suspect there will be some announcements within the next few months that unveil some of the pieces to the puzzle. This is an area that greatly interests me, and I intend to follow the developments of Oslo very closely. As a side effect, I anticipate becoming much more intimate with BizTalk this year.

Parallel LINQ (PLINQ)
I have always been fascinated by the complexities of parallel processing. It has so much potential to provide truly scalable solutions that really harness the capabilities of the underlying hardware. However, let's be honest. Parallelism is not a simple programming endeavor. It can quickly become very complicated, and a lot of developers have a hard time really understanding the intricacies of multithreaded execution. Furthermore, the current state of the hardware is making it difficult to ignore the necessity of parallelism. In seven years from now (maybe sooner) when there are CPUs with 128 cores, you will have a hard time taking advantage of the hardware if you are still programming in a single-threaded sequential fashion. Fortunately, PLINQ has a lot of promise for making the lives of developers much simpler in regards to parallelism. During the coming months, I intend to delve more deeply into PLINQ and it will likely be the subject of a number of posts.

F#
Functional programming has recently received a lot of attention, particularly in the realm of Microsoft .NET. Personally, I think F# has a lot to do with it. While it is still considered an incubation project within Microsoft Research, it has been revealed that F# will become a featured language of .NET with full support in Visual Studio. I'm really excited about the benefits this language has to offer. While many of the concepts are still somewhat foreign to me because of my imperative programming background, there have been a number of "wow" moments from listening to podcasts from DNR and Hanselminutes that featured F#. Within the next month or so, you should begin to see a few posts showing up here about F#. I suspect there will be some good material to write about as I attempt to wrap my mind around many of the functional programming concepts.

Don't Use Types for Locking

jeff.barnes — Thu, 07 Feb 2008 10:00:20 GMT

Earlier this week, I posted a reminder that static methods don't always require locking. However, I also wanted to emphasize to exercise caution when selecting the object that will be used for a lock. For years, there have been many examples that use the containing type for the lock object, but this is not really a good idea.

Here's an example of the wrong way:

public class MyClass
{
    private static int _counter = 0;

    // Don't do this!
    public static int StatefulAdd(int value1, int value2)
    {
        lock (typeof(MyClass))
        {
            _counter++;
        }

        return value1 + value2;
    }
}

There have been numerous publications and blog articles written with locking examples that do something similar. However, this is not a recommended best practice, and Microsoft has been attempting to modify their documentation to reflect the preferred approach. Before I get into the recommended approach, let me clarify what's wrong with the other solution.

First, the typeof operator is relatively slow, at least when compared to accessing a variable within the class. Second, typeof returns a Type object, which is a publicly accessible object. As such, any other class could choose to lock on the same object, which opens up the potential for deadlock scenarios.

So, what is the recommended best practice? Rather than using a Type object or some other publicly accessible object, it is recommended to use a private static member variable. This ensures that only the implementation within the containing type has access to the lock object.

Here's an example of the right way:

public class MyClass
{
    private static int _counter = 0;
    private static object _lockObject = new object();

    // Do this!
    public static int StatefulAdd(int value1, int value2)
    {
        lock (_lockObject)
        {
            _counter++;
        }

        return value1 + value2;
    }
}

For a more insight into possible problems with the typeof approach, there are a couple of articles that I recommend reading. Here is a link to an MSDN article from 2003. Here is a link to a blog post from Joe Duffy aka Threading Master. Even though the MSDN article was dated back in 2003, I have still seen some articles as recently as 2007 that still contain examples of using typeof. As they say, some habits die hard.

IPSA Meeting - February 8th

jeff.barnes — Wed, 06 Feb 2008 22:20:59 GMT

The February meeting for the Internet Professionals Society of Alabama (IPSA) will be on Friday, February 8th. The meeting will be held from 12PM to 1PM in the Special Events Room of the McWane Science Center. There will be designated networking time from 11:30AM to 12PM prior to the beginning of the presentation.

Jere Chandler will be presenting "Simplicity in Design". Here is the abstract:

Simplicity in design is one of the primary concepts that will give software companies a competitive advantage over the next few years. Jere Chandler, a User Experience Engineer for DAXKO, will discuss why simplicity is so important, the reasons we tend to complicate things, and why the software that's easiest to use is usually the most difficult to create.

Be sure to RSVP at the site if you are planning to attend.

I'll see you there.

BSDA Meeting - February 7th

jeff.barnes — Wed, 06 Feb 2008 22:17:44 GMT

I meant to post about this earlier in the week, but I suppose it is better late than never.

On Thursday, February 7th, the Birmingham Software Developer Association will be meeting at New Horizons. Doug Turnure, our regional Microsoft .NET Developer Evangelist, will be giving a technical overview of Visual Studio 2008 and LINQ. The presentation will begin at 6:30 PM.

If you haven't had an opportunity to learn much about VS2008 and what it has to offer, this will be a good chance to do so.