Pluralsight Blogs

Tito's Tacos

don-box — Wed, 20 Aug 2008 03:34:00 GMT

PDC is increasingly taking up my time, so I've got LA on the brain.

Having lived in LA for 39 years before joining the firm, I use PDC as an opportunity to visit my favorite haunts.

My first stop will be Tito's Tacos. Every time I go to LA (PDC or not), I go straight from LAX to Tito's.

For the PDC trips, I take as many people from my flight as possible.

My recommendation is some combination of Tacos (with cheese) and Tostadas. Skip the burritos - way too much food and you don't get that magical super-fresh lettuce/cheese combo happening.

Mary Jo's Codename Roundup

don-box — Wed, 20 Aug 2008 03:13:00 GMT

Ms. Foley has a call out for Microsoft codenames over at ZDNet.

I first read this on my phone and was busy coming up with names I thought would be interesting project names.

Unfortunately when I got home and read the blog, it was clear she was looking for actual names of existing projects, which I find way less interesting or fun.

At the risk of incurring the wrath of MJF, let me be perfectly clear that the names I'm listing here have no known correlation to any existing or future projects.

I just like the names.

Penultimate

Project Fifty Seven

Neville

Valhalla

Folsom

Cleveland

Loki

XK-4

Maybe once Oslo is behind me I'll get a chance to pick one of these up for my next gig...

Pluralsight's WCF/WF Developer Screencast Series

aaron-skonnard — Tue, 19 Aug 2008 23:44:52 GMT

Pluralsight has joined forces with the WCF/WF teams at Microsoft to deliver a series of short videos that illustrate how to get started using WCF/WF in your applications. The videos will be hosted on Channel9 within the Screencasts section, and they'll be highlighted on The .NET Endpoint Team Blog and the MSDN Dev Centers for WCF & WF. These videos provide 100-200 level content intended for folks new to the technology or those looking for quick tutorials on how to perform common tasks within each framework.

Cliff Simpkins announced the first video in the WCF series last week -- you can find it over here on Channel9. It's called Creating Your First WCF Service. This short video guides you through how to create your first WCF Service from scratch in VS2008 - defining a data contract, a service contract, and testing/hosting the service using the new built-in WCF tools found in VS2008.

A new video will be posted every week in the series...so check back on Channel9 if you're interested! And if you like what you see, you should also check out Pluralsight's new online training system that is currently in beta at the moment. You'll be hearing more about this over the next few months but if you're interested in participating in our early-adopter program, shoot me an email.

Programming the MetaWeblog API in .NET/C#

aaron-skonnard — Tue, 19 Aug 2008 23:09:10 GMT

Most modern blogging engines support the MetaWeblog API, which was defined by XML-RPC.com many years ago. It's become one of the most popular API's for programmatically interacting with blogs because of its simplicity. Even Microsoft's Windows Live Spaces provides support for it.

I wanted to use this API recently to interact with our Community Server implementation so I started searching around for client-side implementations that would be easy to program in C#. I was surprised that I couldn't find a mainstream implementation readily available. So I followed the example on MSDN and built my own MetaWeblog library in C# on top of Cook Computing's XML-RPC.NET library.

Here's what my MetaWeblogClient class looks like (truncated for brevity):

public class MetaWeblogClient : XmlRpcClientProtocol
{
    [XmlRpcMethod("metaWeblog.getRecentPosts")]
    public Post[] getRecentPosts(string blogid, string username, string password, int numberOfPosts)
    {
        return (Post[])this.Invoke("getRecentPosts", 
            new object[] { blogid, username, password, numberOfPosts });
    }

    [XmlRpcMethod("metaWeblog.newPost")]
    public string newPost(string blogid, string username, string password, Post content, bool publish)
    {

        return (string)this.Invoke("newPost", 
            new object[] { blogid, username, password, content, publish });
    }
    ...

With this class, you can simply make method calls like getRecentPosts, newPost, editPost, etc to interact with any blog that supports the MetaWeblog API. You will need to specify that URL to the MetaWeblog endpoint prior to making those method calls. Here's an example:

class Program
{
    static void Main(string[] args)
    {
        MetaWeblogClient blog = new MetaWeblogClient();
        blog.Url = "http://www.pluralsight.com/community/blogs/metablog.ashx";

        // here's how you post a new entry...
        Post newPost = new Post();
        newPost.dateCreated = DateTime.Now;
        newPost.title = "Test post from Metablog Api";
        newPost.description = "This is the body of the post";
        newPost.categories = new string[] { "WCF", "WF" };
        blog.newPost("blogid", "username", "password", newPost, true);

        // here's how you retrieve the most recent entries...
        Post[] posts = blog.getRecentPosts("blogid", "username", "password", 5);
        foreach (Post post in posts)
            Console.WriteLine(post.title);
    }
}

The code turns out to be wonderfully simple. So if you find yourself in the same boat as me, looking for a MetaWeblog C# implementation, feel free to download my library here. Hopefully it will save you a little bit of time!

Learning Parallel Programming --- from shared-memory multi-threading to distributed-memory multi-processing

joe-hummel — Tue, 19 Aug 2008 03:29:00 GMT

We're working with Microsoft to develop several tutorials introducing developers to high-performance computing, parallel programming, and Windows HPC Server 2008. Our first tutorial (for experienced HPC developers, "Exploiting Data Parallelism with OpenMP, MPI and HPC Server 2008"), is available here. We are working on our second tutorial, "From Sequential to Parallel Development", which is nearing completion. This is more introductory in nature, taking the traditional "sequential" developer step-by-step into the world of parallel programming. The tutorial is extensive, currently 50 pages in length, complete with source code, lab exercises, and solutions in both VC++ and C#.

We start with a GUI-based Mandelbrot application, and show various ways to parallelize the application via multi-threading --- explicitly with .NET threads, then implicitly with OpenMP and the TPL (Task Parallel Library in the upcoming PFx, or Parallel Extensions to .NET). We then architect a client-server version of the Mandelbrot app, introduce Windows HPC Server 2008, and show how to parallelize the app across a cluster. This includes a discussion of many topics, including:

Multi-threading
Multi-processing
BackgroundWorker and Thread classes
OpenMP
TPL
MPI
MPI.NET
programming against the HPC Server 2008 API
automating application deployment and job submission

The goal is to show developers how to take a sequential, GUI-based application and parallelize this app across both multi-core and cluster-based hardware. Here's the current draft of the tutorial document: SeqToParallelHPC.pdf. The current download including source code and lab exercises: SeqToParallelHPC.zip. Any and all feedback greatly appreciated. Enjoy!

Serializable XmlDocument

keith-brown — Tue, 19 Aug 2008 02:58:00 GMT

It's surprising that XmlDocument isn't marked [Serializable], because it's very natural to serialize one into a stream. I wanted to put an object into ASP.NET ViewState the other day, and quickly ran into this roadblock, because part of the object included an XmlDocument, which is not serializable. A quick search revealed that most people deal with this problem by storing a string instead. Indeed, that was where I started, but I quickly realized that there are multiple places in my code where I want to do this sort of thing, and I don't want to have to mess with it in each data structure that contains an XmlDocument.

So I put together a simple class that holds an XmlDocument and implements ISerializable and called it SerializableXmlDocument. I'm sharing the source code here in the hopes that

a) somebody will find it useful, and

b) somebody smarter than I am will point out how I screwed it up and help me make it better.

SerializableXmlDocument includes implicit conversion operators to make it easy to convert to/from an XmlDocument. It holds the actual document in a property called Value. This "isomorph" pattern is one that I picked up from Craig.

While writing this code, I also wrote a helpful extension method for getting a byte array out of a MemoryStream that is exactly the length of the data written to the stream so far (CopyUpToSeekPointer). So don't go looking in the docs for MemoryStream for this method :) This is obviously not the most efficient way to consume bytes written to a MemoryStream since it copies the data into a new byte array, but it's very convenient in many scenarios.

Here is SerializableXmlDocument.cs:

using System;
using System.Runtime.Serialization;
using System.Xml;
using System.IO;

namespace Pluralsight.Samples
{
    [Serializable]
    public class SerializableXmlDocument : ISerializable
    {
        public SerializableXmlDocument() { }
        public SerializableXmlDocument(XmlDocument value)
        {
            this.Value = value;
        }

        public XmlDocument Value { get; set; }

        #region ISerializable implementation
        public SerializableXmlDocument(SerializationInfo info,
                                       StreamingContext context)
        {
            byte[] serializedData = (byte[])info.GetValue("doc",
                typeof(byte[]));
            if (null != serializedData)
                this.Value = Deserialize(serializedData);
        }

        public void GetObjectData(SerializationInfo info,
                                  StreamingContext context)
        {
            byte[] serializedData = null;
            if (null != Value)
                serializedData = Serialize(Value);
            info.AddValue("doc", serializedData);
        }
        #endregion

        #region implicit conversion to/from XmlDocument
        public static implicit operator SerializableXmlDocument(
            XmlDocument doc)
        {
            return new SerializableXmlDocument(doc);
        }
        public static implicit operator XmlDocument(
            SerializableXmlDocument sdoc)
        {
            return sdoc.Value;
        }
        #endregion

        #region Xml serialization helper methods
        private static byte[] Serialize(XmlDocument doc)
        {
            MemoryStream stream = new MemoryStream();
            doc.Save(stream);
            return stream.CopyUpToSeekPointer();
        }
        private static XmlDocument Deserialize(byte[] serializedData)
        {
            XmlDocument doc = new XmlDocument();
            doc.Load(new MemoryStream(serializedData, false));
            return doc;
        }
        #endregion
    }
}

...and here's the CopyUpToSeekPointer extension method for MemoryStream:

using System;
using System.IO;

namespace Pluralsight.Samples
{
    public static class MemoryStreamExtensionMethods
    {
        public static byte[] CopyUpToSeekPointer(
            this MemoryStream stream)
        {
            // copy only the part of the buffer
            // that contains the serialized document
            long length = stream.Position;
            byte[] buffer = stream.GetBuffer();
            byte[] result = new byte[length];
            for (int i = 0; i < length; ++i)
                result[i] = buffer[i];
            return result;
        }
    }
}

...and here's a sample object that uses SerializableXmlDocument:

using System;

namespace Pluralsight.Samples
{
    [Serializable]
    public class Item
    {
        public string Name { get; set; }
        public SerializableXmlDocument Data { get; set; }

        public void Print()
        {
            Console.WriteLine("Name: {0}", Name);
            Console.WriteLine(Data.Value.OuterXml);
        }
    }
}

...and here's a sample program that creates an instance of Item, serializes it, then deserializes it, printing diagnostics along the way to show that it's working properly.

using System;
using System.Xml;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using Pluralsight.Samples;

class DemoProgram
{
    static void Main(string[] args)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml("<root><child>text</child></root>");

        Item item = new Item
        {
            Name = "Testing 123",
            Data = doc,
        };

        // print object before serialization
        item.Print();

        BinaryFormatter formatter = new BinaryFormatter();
        MemoryStream stream = new MemoryStream();
        formatter.Serialize(stream, item);

        byte[] serializedItem = stream.CopyUpToSeekPointer();

        Console.WriteLine("Serialized data (base64): {0}",
            Convert.ToBase64String(serializedItem));

        item = (Item)formatter.Deserialize(
            new MemoryStream(serializedItem, false));

        // print object after deserialization
        item.Print();
    }
}

Here's the output of the previous sample program:

Flame away!

Impromptu Vacation

don-box — Sat, 16 Aug 2008 05:37:00 GMT

For the first time ever, I took a completely spontaneous vacation by booking a flight Wednesday to head out to Martha's Vineyard to hang out with my wife & kids (and Sara Spalding's husband and kid).

I really like Martha's Vineyard - I also really like not having to make any plans.

Swimming in the Atlantic is also pretty cool - I forgot how much I like the ocean after 6+ years living near Lake Washington.

Two-way formatted data binding in ASP.NET

keith-brown — Fri, 15 Aug 2008 20:22:37 GMT

Two way data binding in ASP.NET is easy, just use the Bind expression and data will flow between your web controls and your data source flawlessly. Until that is, you try to use a format string:

Bind("AmountCharged", "{0:C}")

While this displays just as you'd expect (e.g., $200), it doesn't do so well when you submit an edit that includes the same value ($200):

Input string was not in a correct format.

I searched around and didn't find much in the way of a clean solution, but I did solve the problem with just a few lines of code. The trick is to handle the data-bound control's Updating event. Since I was working with a GridView, my solution looked a bit like this:

<asp:GridView DataSourceID='myDataSource'
              OnRowUpdating='FixFormatting'
              AutoGenerateColumns='false'
              CellPadding="3" ...>

Notice the OnRowUpdating handler that I've installed in my grid view. That code looks like this:

protected void FixFormatting(object sender, GridViewUpdateEventArgs args)
{
    decimal amountPaid = ParseDecimal((string)args.NewValues["AmountPaid"]);
    args.NewValues["AmountPaid"] = amountPaid;
}

When you handle this event, you're given a dictionary of old and new values, which appear to come directly from the controls (in my case, a TextBox was used to gather the updated data AmountPaid, so the type of object that I found in NewValues["AmountPaid"] was a string. I wrote a little helper method called ParseDecimal that parses a string into a decimal value, allowing currency characters, decimal points, and thousands separators. I also allowed a blank value to indicate zero:

public static decimal ParseDecimal(string value)
{
    if (string.IsNullOrEmpty(value))
        return 0;
    return Decimal.Parse(value,
        NumberStyles.AllowThousands |
        NumberStyles.AllowDecimalPoint |
        NumberStyles.AllowCurrencySymbol,
        CultureInfo.InstalledUICulture);
}

This solved the problem quite nicely. Now two-way binding works with formatted data.

Musculosenioritis

mike-woodring — Wed, 13 Aug 2008 15:40:21 GMT

[muhs-kyuh-loh-seen-yawr-eye-tis]

-noun Pathology

soreness and weakness of the muscles, generally following athletic physical exertions reminiscent of the sufferer’s younger days; typically accompanied by the onset of stiffness and reduced ambulatory mobility during the 24-72 hours following the cessation of athletic activities.

[origin: August 4-13, 2008; musculo- + senior + -itis]

I finally have a diagnosis. Over the past few years, I’ve periodically suffered from a near-debilitating condition that results in great difficulty walking as well as moving from a sitting to a standing position; especially following prolonged periods of programming involving only the movement of my fingers and eyes. Until today, nobody could tell me what it was I was suffering from.

This condition generally sets in after I compete in athletic events (soccer, in my case), where I run, jump, and otherwise exert myself as if I were still a strong, fit athlete younger than 24 years of age. Alas, it has become increasingly apparent to me that this is no longer the case. In my case, the breakthrough diagnosis came last night after the adult, co-ed soccer team I’m a member of completed our run at this year’s trophy. We competed in 4 matches over a 4 day period last week, had the weekend off to ice and medicate our aches and pains, and then kicked off this week by competing in 2 more matches over the past 2 days.

As I sat on the sidelines after our loss last night, physically depleted and sapped of every last scrap of energy within me, I wondered what had brought me to this low point in my life. What malady was it that I could feel setting in even as I sat there limp with fatigue? What was it that caused such foreboding of what was to come this morning – a condition that I knew would worsen over the next few days as I sat here at my computer, typing lambda expressions and disassembling the contents of memory pointed to be the EIP register? What was it that could cause such physical pain merely attempting to rise from my chair and walk upstairs to refill my coffee cup?

And then it came to me - a word that so perfectly describes the condition suffered by myself and so many other over-the-hill athletes around the world: musculosenioritis.

Yes, I finally have a name for my tormentor. Like so many other afflictions, there is no known cure. Some would point to studies that indicate the condition can be ameliorated by abstaining from athletic competition clearly suited to younger, more physically fit personnel. But abstinance is no cure – it’s avoidance. And I will always choose to face my challenges head on; without quitting.

And so I will take what comfort I can just knowing that my affliction now bears a name, and that I am not alone in my suffering.

Visual Studio SP1 and The Metification of REST

scott-allen — Tue, 12 Aug 2008 02:39:00 GMT

Metification – verb

The act of adding metadata to a web service in order to facilitate tooling and discovery.
The act of adding complexity to a web service in order to achieve tight coupling.

Pick one.

Service Pack 1 for Visual Studio 2008 has just arrived with new features, including version 1.0 of ADO.NET Data Services (a.k.a Astoria). From the description (highlighting is mine):

ADO.NET Data Services … consists of a combination of patterns and libraries that enables any data store to be exposed as a flexible data service, naturally integrating with the Web, that can be consumed by Web clients within a corporate network or across the Internet. ADO.NET Data Services uses URIs to point to pieces of data and simple, well-known formats to represent that data, such as JSON and ATOM/APP. This results in data being exposed to Web clients as a REST-style resource collection, addressable with URIs that agents can interact with using standard HTTP verbs such as GET, POST, or DELETE.

Compared to the traditional SOAP approach, the REST-style is a different model for exposing functionality over a web service. Instead of defining messages and exposing operations that act on those messages, you expose resources and act on the resources using common HTTP verbs. I’ve lately been thinking of SOAP based web services as “verb oriented” (exposing GetOrder and UpdateCustomer), while REST style web services are “noun oriented” (exposing Orders and Customers). Both models have advantages and disadvantages, but I’ve felt that REST partners well with rich, Internet applications that need to retrieve a variety of resources using the same filtering and paging parameters. Modeling a heap of GetThisByThat operations using SOAP is tedious.

Noun and verbs aren’t the only difference between REST and SOAP. One of the primary strengths of REST is its inherent simplicity. The simplicity not only facilitates broad interoperability, but encourages an acceptance of REST from many who feel overwhelmed by the complexities of WS-*. There are no tools required for REST - all you need is the ability to send an HTTP request and read the response. WS-*, on the other hand, is great when you need a digitally signed message including double-secret user credentials routed through an asynchronous and distributed, two-phase commit transaction with an extended buyer protection. Not everyone needs that flexibility, but you still pay the price for the flexibility when using the tooling and the API, and when configuring the service.

Although we could continue talking about differences in REST and SOAP, I wanted to talk about metadata, and Astoria.

Metafication

REST proponents, as a rule of thumb, shun metadata – but not all forms of metadata. Metadata in prose or written documentation is fine. Metadata in a self-describing response format is fine. However, metadata for tooling is seen by many as pure evil. Part of the complexity in WS-* is in the quirky and convoluted folds of metadata formats like WSDL and XML Schema. REST has seen some attempts at standardized metadata (WADL, WSDL 2.0, XSD), but still resists all attempts for the most part.

I like metadata. Maybe I’ve been in the .NET ecosystem for so long that I expect tooling, but I still remember the first time I tried to write a program for the Flickr web service (which is technically just POX). I was shocked when I coudn’t find a WSDL file. Then I was surprised at how easy it was to craft the correct URL for an HTTP request, and shred apart the XML response to find photographs. It was so easy that ... well, it was just too easy. It reminded me of writing data access code from scratch. Data access code is so predictable and repetitive that we have tools, frameworks, and code generators to take care of the job. But those tools, frameworks, and code generators rely on metadata defined by a database schema, so their job is relatively straightforward. REST is a bit different, unless you are working with Astoria on the server and a CLR client.

Let’s say you have some DTOs for employees, orders, and other objects you want to send over the wire. You’ll need to decorate them with enough information for the service to understand the primary key.

[DataServiceKey("ID")]
public class Employee
{
   
    public int ID { get; set; }
    public string Name { get; set; }
}
[DataServiceKey("ID")]
public class Order
{
    // …
}

Next, define a class with public IQueryable<T> properties for each “entity set” (Employees and Orders). IQueryable<T> is easy to conjure up, and the class below represents a read-only data source with some fake in-memory data. If you need create, update, and delete functionality the class will need to implement IUpdateable, too. Sean Wildermuth has a three series blog post about IUpdateable that he wrote when implementing IUpdateable for the NHibernate LINQ project.

public class AcmeData 
{
    public IQueryable<Employee> Employees
    {
        get 
        {   return new List<Employee>
            {
                new Employee() /* ... */,
                new Employee() /* ... */,
                new Employee() /* ... */
                // ...
            }.AsQueryable();        
        }
    }

    public IQueryable<Order> Orders
    {
        // ...
    }
    // ...
}

Then you need an .svc file…

<%@ ServiceHost Language="C#" 
    Factory="System.Data.Services.DataServiceHostFactory, 
             System.Data.Services, 
             Version=3.5.0.0, Culture=neutral, 
             PublicKeyToken=b77a5c561934e089" 
    Service="AcmeDataService" %>

… and you’ll also need a code-behind file for the .svc (which is all setup for you using an ADO.NET data service template, you just add some configuration):

public class AcmeDataService : DataService<AcmeData>
{        
    public static void InitializeService(IDataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("Employees", EntitySetRights.AllRead);
        // ... more rules
    }
}

At this point you can start testing the service using a web browser and looking at, for example, http://localhost/AcmeDataService.svc/Employees. What is more interesting is looking at http://localhost/AcmeDataService.svc/$metadata, because there you’ll find service metadata, which is where the magic starts.

To consume the service, right-click on a project in Visual Studio and select “Add Service Reference…”. Yes – the same “Add Service Reference” command you might have seen in the hit motion picture “SOAP and WSDL – an XML Love Story”. This feature blurs the lines between REST and WS-*. Enter the root URL to the service and Visual Studio will generate a proxy – but not the type of proxy you receive when using SOAP based web services. This proxy will derive from DataServiceContext class and you can use it like so:

var employees = new AcmeData(serviceRoot)
                    .Employees
                    .Where(e => e.Name == "Scott")
                    .OrderBy(e => e.Name)
                    .Skip(2)
                    .Take(2)                      
                    .ToList();

DataServiceContext does a little bit of magic to turn the LINQ query into the following HTTP request. It’s LINQ to REST:

GET /AcmeDataService.svc/Employees()
    ?$filter=Name%20eq%20'Scott'&$orderby=Name&$skip=2&$top=2 HTTP/1.1
User-Agent: Microsoft ADO.NET Data Services
Accept: application/atom+xml,application/xml

The data service will respond with some XML that the data context uses to create objects that look just like the server side DTOs.

I’m sure some are horrified at this metification of REST, but for scenarios when you need to talk between two CLR appdomains (think ASP.NET and Silverlight), this approach gives you the advantages of thinking about nouns in a RESTful model without writing all the glue code to wire up an endpoints and parse XML. Beauty!

Visual Studio 2008 SP1 and Team Foundation Server 2008 SP1 available now

brian-randell — Mon, 11 Aug 2008 18:05:00 GMT

On MSDN Subscriber downloads.

A quick look at the Microsoft.com downloads site and I don't see it yet for the .NET Framework 3.5 but I imagine soon.

Update:

.NET Framework SP1 is here.

VS is here .

Thanks to Paolo Barone for the links.

And now TFS is showing up too here.

DasKeyboard Enabled

fritz-onion — Fri, 08 Aug 2008 16:58:00 GMT

After reading Scott Hanselman's review of DasKeyboard, I knew one was in my future. I'm very finicky about how my keyboard feels, and for the past several years have been using a Thinkpad keyboard for my desktop which I quite like, it's exactly like typing on my Thinkpad laptop. But when I read how this keyboard clicked like the old IBM 101s (which I loved) and had mechanical key switches, I was sure I'd love it.

Well, it arrived today, and it is by far the best keyboard I've ever typed on. It's very satisfying to type on - especially if you can type fast, you get this nice clickety-clackety sound going that makes you want to keep typing faster. An in case you're wondering, yes, I got the ultimate version with 100% blank keys. It appealed to me as a classical guitarist (my non-tech hobby) where you have to have an innate feel for where each fret is because there are no visual indicators on the fretboard to help you. Having no symbols on the keys means you have to 'just know' - no hunting and pecking allowed. Like the guitar, it takes some getting used to, but in the end it changes the way you interact with the computer. There are two raised bars on the 'f' and 'j' keys to help your hands get to home position. Keith told me I should file them off - only then would I truly be at one with the keyboard :)

Value Stream Mapping

david-starr — Wed, 06 Aug 2008 21:01:44 GMT

Note: Alan just finished recording an Elegant Code Cast with me that will be published later.

I attended Alan Shalloway’s session at Agile 2008 on Value Stream Mapping. I have been wanting to pick up the skill of creating value stream maps for some time and this is a great introduction to the idea. Value Stream Mapping is essentially modeling a problem in terms of Lean and looking for opportunities to optimize your organization in terms of Lean.

Frankly, this looks like typical Business Process Modeling with the added dimension of the value you are trying to optimize for. It also looks similar Root Cause Analysis. I will definitely try this in the real word to see how effective a communication device this model can be.

Here are the steps of creating a value stream map.

Identify Actions Performed in the Value Stream
1. Identify the stream of work between idea conceptualization and delivery to a customer
2. Model the major process and gates involved in creation and delivery
Determine Calendar Time
1. How long does it take to get from conceptualization to delivery
Calculate Time Actually Worked on the Action
1. Measure time per person
Identify Times Between Actions
1. How long do you pause in between actions?
Identify Loop Backs Required
1. How much rework is occurring?
2. How many pieces of work are being rejected for defects?
Identify how many items are waiting in any queues in the system.
1. Are there any queues occurring before actions in the process?
2. How large are they? Don’t go overboard here, just look for big or little.
Compute Process Cycle Efficiency
1. Process Cycle Efficiency = Tome Worked/Total Cycle Time
  - This is pretty self evident and pretty cool. How many of us actually look at this?
  - 509 hrs/3433 hrs = 14.9% efficiency
  - This is worth shock value, but it the key is to raise the % by reducing the denominator
  - If you can approach 50% in software development, you are cooking well. Most teams run between .01% and 8%. Agile teams typically run around 30%.

Other Notes

Single Piece Flow is always a theme with Alan and today was no exception. Single piece flow is a technique of optimizing the whole and reducing time to market by focusing on one thing at a time.
Determine the prime metric of value before you begin. Are you measuring time, cost, quality, or what?
Focus on delays and loop backs for optimizations
Value streams may be created on a feature by feature basis
“Metrics as they are applied today are almost always counterproductive.”
“The best metric I know is end-to-end cycle time.”
“Measuring the efficiency of a single step is extremely counterproductive.”

My Life in a Bush of Legacy Code – Michael Feathers

david-starr — Wed, 06 Aug 2008 20:56:04 GMT

I am attending this session from the godfather of legacy code. How could I pass it up?

Michael’s core assertion is that a code base reflects the business climate of the organization that created it.

Session Quotes

The result of my book has been the opportunity for me to see some of the worst code you can imagine.
Two things we deal with: Laziness and ignorance. Ignorance is forgivable and correctable.
Code is alive and it has its own defenses. A big one is the code’s complexity increases in order to keep you from messing with it. Like a garden getting out of control.
- Personal Note: I like to think about this as “trending to entropy”. Organic systems (like a code base or a human) ill trend to entropy without constant attention to its health.
Organic systems go through periods of recession and recovery.
- Like breaking down muscles to get stronger.
- Like the U.S. economy today.
If an organization has no competition, code will atrophy
TCO of a code base increases due to complexity, not its size.
The way of the magpie is to chase shiny things. Magpie’s create sticky balls of mud. Don’t be a magpie.
Emergence works. Put a small group of people together and let them own a problem. They will almost always succeed.
Dunbar’s Number. Look it up, this is cool. Group sizes larger than this require restrictive rules, laws, and policies in order to maintain stability.

My question: “Do you have some prescriptive guidance for an individual team member who would like to evolve the the team and reclaim a code base that has trended toward entropy?”

Have someone on the team who can do green field TDD. Someone on the team needs to understand what to strive for.
Set standards for quality and team behavior and hold people accountable to those standards.
Find the area of code that everyone is scared of. Attack that one first. The team will feel better having relieved its pain and realized initial success.
- Note: This one reminds me of Mary Poppendieck’s saying, “Find the thing that is hard to do, and do it more often.”

Where to get Password Minder

keith-brown — Tue, 05 Aug 2008 17:00:00 GMT

We recently updated our website and some links have broken as a result. Here's the place you should go to get the latest version of Password Minder:

http://mercury.pluralsight.com/tools.aspx

Sorry for any inconvenience!

Welcome Sahil!

fritz-onion — Mon, 04 Aug 2008 14:45:46 GMT

It is with great pleasure that I introduce Sahil Malik as a Pluralsight instructor. Sahil comes to us with plenty of real-world experience working with clients deploying SharePoint solutions, as well as years of instructional experience - a perfect match for our expectations here at Pluralsight. He will be joining Brian Randell to round out our SharePoint curriculum, focusing his efforts on MOSS. Welcome Sahil - I'm sure you will find the assimilation painless ;)

Better exception reporting in ASP.NET part 2

keith-brown — Mon, 04 Aug 2008 14:11:14 GMT

This is the third post in a series.

The first post described the problem: ASP.NET wasn't reporting inner exception stack traces.

The second post described my solution.

This post shows the code I used to solve the problem: a custom email provider for the Health Monitoring system in ASP.NET. Enjoy!

Here's the provider. Note that I opted *not* to build a buffering provider to keep things simple:

public class MyMailWebEventProvider : WebEventProvider
{
    string to;
    string from;
    string subjectPrefix;

    public override void Initialize(string name,
        NameValueCollection config)
    {
        base.Initialize(name, config);

        to = GetAndRemoveStringAttribute(config, "to", true);
        from = GetAndRemoveStringAttribute(config, "from", true);
        subjectPrefix = GetAndRemoveStringAttribute(config,
            "subjectPrefix", false);
    }
    public override void ProcessEvent(WebBaseEvent raisedEvent)
    {
        SendMail(raisedEvent);
    }

    private void SendMail(WebBaseEvent raisedEvent)
    {
        string subject = ComputeEmailSubject(raisedEvent);
        string body = ComputeEmailBody(raisedEvent);

        MailMessage msg = new MailMessage(from, to, subject, body);
        new SmtpClient().Send(msg);
    }

    private string ComputeEmailBody(WebBaseEvent raisedEvent)
    {
        WebRequestErrorEvent errorEvent =
            raisedEvent as WebRequestErrorEvent;
        if (null != errorEvent)
            return ErrorEventFormattingHelper.FormatRequestErrorEvent(errorEvent);
        else return raisedEvent.ToString();
    }

    private string ComputeEmailSubject(WebBaseEvent raisedEvent)
    {
        StringBuilder subjectBuilder = new StringBuilder();

        // surface some details in subject about error events
        WebBaseErrorEvent errorEvent = raisedEvent as WebBaseErrorEvent;
        if (null != errorEvent)
        {
            Exception unhandledException = errorEvent.ErrorException;

            // drill through reflection exceptions to show the root cause
            TargetInvocationException invocationException =
                unhandledException as TargetInvocationException;
            if (null != invocationException)
            {
                Exception innerException =
                    DrillIntoTargetInvocationException(invocationException);
                subjectBuilder.AppendFormat("{0}",
                    (innerException ?? invocationException).GetType().Name);
                if (null != innerException)
                    subjectBuilder.Append(" (via reflection)");
            }
            else subjectBuilder.Append(unhandledException.GetType().Name);
        }

        // if we've not got anything better
        // just show the event type in the subject
        if (0 == subjectBuilder.Length)
            subjectBuilder.AppendFormat("Event type: {0}",
                raisedEvent.GetType().Name);

        if (!string.IsNullOrEmpty(subjectPrefix)) {
            subjectBuilder.Insert(0, ' ');
            subjectBuilder.Insert(0, subjectPrefix);
        }
        return subjectBuilder.ToString();
    }

    /// <summary>
    /// Reflection often hides exception details, so we try to drill down
    /// through the plumbing exceptions to find a likely cause
    /// </summary>
    private Exception DrillIntoTargetInvocationException(
        TargetInvocationException outerException)
    {
        Exception innerException = outerException.InnerException;
        TargetInvocationException innerInvocationException =
            innerException as TargetInvocationException;
        if (null != innerInvocationException)
            return DrillIntoTargetInvocationException(innerInvocationException);
        else if (null != innerException)
            return innerException;
        else return null;
    }

    private static string GetAndRemoveStringAttribute(NameValueCollection config,
        string attributeName, bool required)
    {
        string value = config.Get(attributeName);
        if (required && string.IsNullOrEmpty(value))
            throw new ConfigurationErrorsException(string.Format(
                "Expected attribute {0}, which is missing or empty.",
                attributeName));
        config.Remove(attributeName);
        return value;
    }

    public override void Flush()
    {
        // nothing to do - this is not a buffering provider
    }

    public override void Shutdown()
    {
        // nothing to do here either
    }
}

Here's a helper class that formats the error messages the way I want to see them. Note that I've omitted some fields that I personally didn't care about, and I've reordered things a bit, so you might want to tweak this if you're going to use it in your own system.

internal static class ErrorEventFormattingHelper
{
    internal static string FormatRequestErrorEvent(
        WebRequestErrorEvent errorEvent)
    {
        CustomEventFormatter formatter = 
            new CustomEventFormatter();

        formatter.AppendLine(string.Format(
            "Unhandled Exception in {0}:",
            WebBaseEvent.ApplicationInformation
            .ApplicationVirtualPath));
        formatter.Indent();
        EmitExceptionAtAGlance(formatter, 
            errorEvent.ErrorException);
        formatter.RevertIndent();

        formatter.AppendLine();
        formatter.AppendLine("Exception stack trace(s):");
        EmitExceptionStackTrace(formatter, 
            errorEvent.ErrorException);

        formatter.AppendLine();
        formatter.AppendLine("Event information:");
        formatter.Indent();
        EmitEventInfo(formatter, errorEvent);
        formatter.RevertIndent();

        formatter.AppendLine();
        formatter.AppendLine("Application information:");
        formatter.Indent();
        EmitApplicationInfo(formatter, 
            WebBaseEvent.ApplicationInformation);
        formatter.RevertIndent();

        formatter.AppendLine();
        formatter.AppendLine("Process/thread information:");
        formatter.Indent();
        EmitProcessInfo(formatter, 
            errorEvent.ProcessInformation);
        formatter.RevertIndent();

        formatter.AppendLine();
        formatter.AppendLine("Request information:");
        formatter.Indent();
        EmitRequestInfo(formatter, 
            errorEvent.RequestInformation);
        formatter.RevertIndent();

        return formatter.ToString();
    }

    private static void EmitEventInfo(
        CustomEventFormatter formatter,
        WebBaseEvent theEvent)
    {
        formatter.AppendLine(string.Format(
            "Event code: {0}",
            theEvent.EventCode.ToString(
            CultureInfo.InvariantCulture)));
        formatter.AppendLine(string.Format(
            "Event message: {0}", 
            theEvent.Message));
        formatter.AppendLine(string.Format(
            "Event time: {0}", 
            theEvent.EventTime.ToString(
            CultureInfo.InvariantCulture)));
        formatter.AppendLine(string.Format(
            "Event ID: {0}", 
            theEvent.EventID.ToString("N", 
            CultureInfo.InvariantCulture)));
    }

    private static void EmitApplicationInfo(
        CustomEventFormatter formatter, 
        WebApplicationInformation appInfo)
    {
        formatter.AppendLine(string.Format(
            "Application domain: {0}", 
            appInfo.ApplicationDomain));
        formatter.AppendLine(string.Format(
            "Application Virtual Path: {0}", 
            appInfo.ApplicationVirtualPath));
        formatter.AppendLine(string.Format(
            "Application Physical Path: {0}", 
            appInfo.ApplicationPath));
    }

    private static void EmitProcessInfo(
        CustomEventFormatter formatter, 
        WebProcessInformation webProcessInfo)
    {
        formatter.AppendLine(string.Format(
            "Process ID: {0}", 
            webProcessInfo.ProcessID.ToString(
            CultureInfo.InvariantCulture)));
        formatter.AppendLine(string.Format(
            "Process name: {0}", 
            webProcessInfo.ProcessName));
        formatter.AppendLine(string.Format(
            "Account name: {0}", 
            webProcessInfo.AccountName));
    }

    private static void EmitRequestInfo(
        CustomEventFormatter formatter, 
        WebRequestInformation webRequestInfo)
    {
        string name = null;
        if (webRequestInfo.Principal != null)
            name = webRequestInfo.Principal.Identity.Name;

        formatter.AppendLine(string.Format(
            "Request URL: {0}", 
            webRequestInfo.RequestUrl));
        formatter.AppendLine(string.Format(
            "Request path: {0}", 
            webRequestInfo.RequestPath));
        formatter.AppendLine(string.Format(
            "User name: {0}", 
            name ?? "[ANONYMOUS]"));
        formatter.AppendLine(string.Format(
            "User host address: {0}", 
            webRequestInfo.UserHostAddress));
    }

    private static void EmitExceptionAtAGlance(
        CustomEventFormatter formatter, 
        Exception exception)
    {
        formatter.AppendLine(string.Format(
            "Type: {0}", 
            exception.GetType().Name));
        formatter.AppendLine(string.Format(
            "Message: {0}", 
            exception.Message));
        if (null != exception.InnerException)
        {
            formatter.Indent();
            formatter.AppendLine("-->Inner Exception");
            EmitExceptionAtAGlance(formatter, 
                exception.InnerException);
            formatter.RevertIndent();
        }
    }

    private static void EmitExceptionStackTrace(
        CustomEventFormatter formatter, Exception exception)
    {
        formatter.AppendLine(exception.StackTrace);

        if (null != exception.InnerException)
        {
            // no point indenting
            // since stack traces typically wrap like crazy
            formatter.AppendLine();
            formatter.AppendLine("-->Inner exception stack trace:");
            EmitExceptionStackTrace(formatter, exception.InnerException);
        }
    }
}

And finally, here's a helper class that manages indentation levels for the output email message:

public class CustomEventFormatter
{
    const int TabSpaces = 4;

    StringBuilder sb = new StringBuilder();
    private int indentLevel;
    private bool startingNewLine = true;

    public void Indent()
    {
        ++indentLevel;
    }

    public void RevertIndent()
    {
        if (indentLevel > 0)
            --indentLevel;
    }

    public void Append(string text)
    {
        if (startingNewLine)
            EmitIndent();
        sb.Append(text);
        startingNewLine = false;
    }

    public void AppendLine(string lineOfText)
    {
        if (startingNewLine)
            EmitIndent();
        EmitIndent();
        sb.AppendLine(lineOfText);
        startingNewLine = true;
    }

    private void EmitIndent()
    {
        sb.Append(' ', TabSpaces * indentLevel);
    }

    public void AppendLine()
    {
        AppendLine(string.Empty);
    }

    public override string ToString()
    {
        return sb.ToString();
    }
}

Build this into a library application and reference it in your config file. Here's an example:

<healthMonitoring>
  <providers>
    <add name="mailWebEventProvider"
         type="MyMailWebEventProvider"
         to="web-fault@fabrikam.com"
         from="website@fabrikam.com"
         buffer="false"
         subjectPrefix="[WEB-ERROR]"
       />
  </providers>
  <rules>
    <add name="All Errors Email"
         eventName="All Errors"
         provider="mailWebEventProvider"
         profile="Default"
         minInstances="1"
         maxLimit="Infinite"
         minInterval="00:01:00"
         custom=""/>
  </rules>
</healthMonitoring>

In Toronto for Agile 2008

david-starr — Mon, 04 Aug 2008 02:13:06 GMT

I drove from Boise to Seattle yesterday to drop off my 4 kids at the grandparents house, then I got up at 4 this morning to catch a plane. Now, I am in Toronto and am really impressed! This place is cool!

There was a street festival in full swing when my friend Ken and I went walking and looking for dinner. Check this picture out: Real break dancers. Seriously, it’s like 1986! Awesome.

I gotta hand it to my buddy. He passed up a limo ride with Mary Poppendieck to come ride to the hotel with me. Now, that’s a real friend :)!

I will be up late tonight polishing my presentation for Thursday, TDD Clinic- .Net and C#.

If you are at the conference this week, watch for me and please say hello. I’d love to meet you!

As always, watch the blog for my session notes as I experience the conference.

Twisted Coronas

keith-brown — Sat, 02 Aug 2008 17:33:51 GMT

Okay it's Saturday, so let me share something completely nontechnical and fun.

What you need to make these cocktails:

Six pack of Corona Extra
Bottle of Bacardi Limon
Lime
Coctail stirrer (a chopstick works fine)

Pop a slice of lime into a Corona and hand to a friend. Have them drink the neck, then refill with Bacardi Limon (putting the lime in first seems to reduce fizzing). Stir and hand back to them so they can drink it down as it fizzes up a bit.

Mixing rum and beer may sound nasty, but this actually results in a very smooth, tasty drink. It's our favorite accompaniment when we are playing Rock Band.

We took this recipe and applied it to one of our other favorite beers as well: Honey Moon Summer Ale (also works with Blue Moon, or any other typically orange-flavored beer). Just use Barcardi O instead of Limon.

Enjoy!

Comments

keith-brown — Fri, 01 Aug 2008 21:38:00 GMT

We recently switched our blog engine out, and I'm still getting the hang of the new system. Looks like due to a misconfiguration, several comments have been waiting for moderation for days or weeks. If yours was one of them, please accept my apology - I didn't have email notifications turned on, so I wasn't being notified that comments were coming in.

I've since fixed the problem, so your comments should show up sooner. Sorry for any confusion!

Better exception reporting in ASP.NET

keith-brown — Fri, 01 Aug 2008 21:30:00 GMT

In my last post, I commented on how ASP.NET health monitoring doesn't output stack traces for inner exceptions, which can be problematic due to its heavy reliance on reflection. I spent the morning doing some further spelunking with reflector, and my first solution was to implement a custom WebEvent that overrides ToString() to format itself with all of the data I care about. I then overrode the Error event via global.asax and raised my custom event, instead of letting ASP.NET raise its default event. This worked reasonably well with the SimpleMailWebEventProvider, but didn't seem to change anything at all with the event log provider.

What I found is that the two providers were using entirely different means to format the events! The email provider calls ToString(bool, bool) on the event to ask it to format itself. But the EventLogWebEventProvider does its own formatting of individual fields of the event. Indeed, its ProcessEvent method has a big list of checks:

if (eventRaised is WebBaseErrorEvent)
    AddErrorStuff();
if (eventRaised is WebAuthenticationSuccessAuditEvent)
    AddLogonStuff();

So it seemed like a better approach would be to write my own provider. I left the event log provider alone, and I wrote a custom email provider to display errors in a more useful way. This also allowed me to drop some fields from the event report that aren't useful for us. And I was able to construct a much more concise and useful subject line (the subject line that SimpleMailWebEventProvider uses is rather clunky since it assumes it might be spitting out a whole bunch of buffered events in one go).

Not only does my provider include the stack traces for all of the exceptions in the chain, but in the subject line, I display the type of error that is at the root of the problem. So if I am formatting a TargetInvocationException, I drill into its InnerException chain until I find a different exception type, and display that exception type instead.

Oh, one other benefit of building the custom provider instead of using a custom WebEvent was that I was then able to remove the Error handler from global.asax. All I had to do was replace the SimpleMailWebEventProvider with my own provider, and I got the behavior I wanted. Now my email notifications include detailed stack traces.

I'll post the code for this provider once it's run for a little while in production and I'm satisfied that it works reasonably well.

UPDATE: I included the code in my third post in this series.

PDC 2008

martin-gudgin — Fri, 01 Aug 2008 18:38:00 GMT

I've been in the U.S. nearly two years now, working away on various things with the rest of the folks on my team. Soon I'll be able to talk about what I've been working on in public; Chris Sells and I will be delivering a talk at PDC 2008, currently entitled "Oslo": Repository and Schemas, catchy, huh?

ASP.NET Health Monitoring doesn't log inner exception stack trace

keith-brown — Fri, 01 Aug 2008 17:21:00 GMT

This can be a problem, especially when an ObjectDataSource starts throwing exceptions. The stack trace looks the same because of the way the methods are invoked (via reflection) - you end up with a stack trace for a TargetInvocationException, which basically says, "I used reflection to invoke some method, and it threw an exception. See the inner exception for details."

ASP.NET's health monitoring system does list the inner exceptions (apparently up to a maximum depth of two, from spelunking the code with reflector), but it does not emit the stack traces for these exceptions, which would be really helpful. I've spent some time this morning trying to figure out how I'd customize things to emit this, and it looks like what I'd have to do is catch the exception and generate a custom WebEvent that overrides ToString(bool, bool) and does everything that WebRequestErrorEvent does, but also generate the inner stack trace.

That seems a bit ugly. A search for "ASP.NET web event inner exception stack trace" yielded no interesting results, so if you've dealt with this and have a cleaner solution, let me know. I'll post my solution once I get it worked out.

UPDATE: I ended up writing a custom email provider.

Simulating Email in .NET

keith-brown — Fri, 01 Aug 2008 16:59:00 GMT

I use email as a notification mechanism a lot, and often in class I'll demo sending email via a technique that I use frequently when developing code. It allows you to simulate sending an email message.

The trick to doing this is not to hardcode things like host, port, etc. for your SMTP server when you use System.Net.Mail to send mail. Instead, use the default ctor for SmtpClient as I've done in the code below.

static void Main(string[] args)
{
    // note the use of the MailAddress class
    // this allows me to specify display names as well as email addresses
    MailAddress from = new MailAddress("admin@fabrikam.com", "Fabrikam Website");
    MailAddress to = new MailAddress("mari@fabrikam.com", "Mari Joyce");

    MailMessage msg = new MailMessage(from, to);
    msg.Subject  = "Testing 123";
    msg.Body = "This is only a test!";

    // note use of default ctor
    // this looks in config to figure out how to send mail
    new SmtpClient().Send(msg);
}

What you're telling .NET by using the default ctor for SmtpClient is, "please use my config file to figure out how to send mail". Now you can use the system.net/mailSettings/smtp section in config to specify the details of your mail server, and all of the code in your app that is written to use the default SmtpClient ctor will inherit these settings. Here's an example of what the config on a production server might look like (if you put passwords in your config files, be sure to encrypt those sections):

<configuration>
  <system.net>
    <mailSettings>
      <smtp deliveryMethod="Network">
        <network host="mail.fabrikam.com"
                 port="25"
                 userName="WebsiteMailAccount"
                 password="whatever"/>
      </smtp>
    </mailSettings>
  </system.net>

</configuration>

During development, I use different settings because I don't usually want to deal with the hassle of installing an SMTP server on my development box. Instead, I want email messages delivered as individual files in a directory on my hard drive (I always have a c:\mail directory on my development box for just this purpose):

<configuration>
  <system.net>
    <mailSettings>
      <smtp deliveryMethod="SpecifiedPickupDirectory">
        <specifiedPickupDirectory pickupDirectoryLocation="c:\mail"/>
      </smtp>
    </mailSettings>
  </system.net>
</configuration>

Now when I run the program above, I get a .EML file in my c:\mail directory:

Outlook Express is normally registered as the viewer for .EML files, so double-click the file to view it:

If you've never seen this method of simulating email before, I hope you find it as useful as I have. Happy coding!

Controlling column width in a GridView

keith-brown — Wed, 30 Jul 2008 17:23:27 GMT

I've been building some internal pages for our sales team here at Pluralsight, and many of those pages make use of the ASP.NET GridView control to display rectangular data. It's generally a really easy to use control, but I've always struggled with getting column widths to look right.

My goal is to fix the width of each column at design time, and any field that contains text that may be longer than my fixed width should wrap around, taking up more vertical space in the table. If you are trying to accomplish this goal, you might find these tips helpful.

1) Set up a CssClass for the GridView itself and include the table-layout:fixed style. This tells the browser that you're going to specify the width of each cell. You may also want to include the overall width of the grid here as I mention in (3).

2) The first row of the table sets the width for each cell, and that's usually the HEADER row, not the item row, so use either HeaderStyle-CssClass or HeaderStyle-Width to set the width of the cell. I wasted a lot of time trying to set the width using the ItemStyle.

3) Make certain the table itself is wide enough to hold all of the cells. I added up all of my cell widths and used that to set the width via the CssClass attribute on the GridView.

Using these guidelines, I'm having much better luck controlling the layout of my GridView controls. I hope this simple advise helps someone else!