My role in all of this was to bring up some very custom roles inside of Windows Azure.  Stuff I can't really talk about now, but, will be able to blog about in the coming months.  It wasn't the most glamorous role on this project, but for me, it was the beefiest, and the best fit.

One thing I can share is that the Windows Azure team is the best.  Microsoft, and our Windows Azure offering, lead by Amitabh Srivastava, is Cloud Computing for real.  The cloud is a 1.0 product, on all fronts, and this platform is the future of computing.

Ray Ozzie / Jack Ozzie / Lili Cheng (in no particular order), leading FUSE Labs, and our team of Ninja developers, PM's, designers, testers, and marketing folks, among which I am proud to be a member, really did some cool stuff with https://docs.com.  I wish I could name the whole team, but, I'm sure I would leave someone out.  You all know who you are.  We all know.

And a special shout out to Pat Kinsel, who played hard, and is a rainmaker.

Best!

Brian

The first step in using caching with CloudDrive is to define a LocalResource for the role in the csdef file:

    <LocalResources>
      <LocalStorage name="AzureDriveCache" cleanOnRoleRecycle="false" sizeInMB="8000" />
    </LocalResources>

Next, you need to initialize CloudDrive caching thus:

var localResource = RoleEnvironment.GetLocalResource("AzureDriveCache");
CloudDrive.InitializeCache(localResource.RootPath, localResource.MaximumSizeInMegabytes);

And finally, mount your drive:

var driveLetter = cloudDrive.Mount(4000, DriveMountOptions.None);

And this is when the problem comes up.  Doing this will result in an exception: HRESULT=D0000033 When calling CloudDrive.Mount

Through logging, I see that the RootPath property above was returned as:

C:\Resources\directory\d15989a9895847ee9672b0f217f427bf.XWorkerRole.AzureDriveCache\

After consulting with the Azure team, I learned that there is a bug in the current SDK, and that the trailing ‘\’ character is the cause of the error.

Remove it, and you’ll be fine.

Best!

Brian

Recently, I’ve been working on a Windows Azure project, and it’s wonderful that Azure Table Storage now includes support for “Entity Group Transactions”.

Here's the MSDN Documentation Page that explains how the feature works.  Steve Marx's Blog Posting is a good read, too.

Essentially, this allows one to batch up to 100 insert, update, merge, and delete transactions into a single batch that will either completely succeed or fail.  (All the entities in the the transaction must be in the same partition of the same table, and the payload of the transaction cannot exceed 4MB.)

If you want to use Entity Group Transactions with disparate entity types against Development Storage, there is a problem that you will need to workaround.

Given:

    public class XEntity : TableServiceEntity
    {
        public XEntity(string p, string r)
            : base(p, r) { }
    }

    public class YEntity : TableServiceEntity
    {
        public YEntity(string p, string r)
            : base(p, r) {}
    }

The following Entity Group Transaction will succeed:

    tableServiceContext.AddObject(EntitySetName, new XEntity("Partition1", "Row1"));
    tableServiceContext.AddObject(EntitySetName, new XEntity("Partition1", "Row2"));
    tableServiceContext.SaveChangesWithRetries(SaveChangesOptions.Batch);

However, if the entities include distinct properties (XProp and YProp in this example):

    public class XEntity : TableServiceEntity
    {
        public XEntity(string p, string r)
            : base(p, r) { }

        public string XProp { get; set; }
    }

    public class YEntity : TableServiceEntity
    {
        public YEntity(string p, string r)
            : base(p, r) {}

        public string YProp { get; set; }
    }

The following Entity Group Transaction will fail:

    tableServiceContext.AddObject(EntitySetName, new XEntity("Partition1", "Row1"));
    tableServiceContext.AddObject(EntitySetName, new YEntity("Partition1", "Row2"));
    tableServiceContext.SaveChangesWithRetries(SaveChangesOptions.Batch);

The error will be:

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<error xmlns="https://schemas.microsoft.com/ado/2007/08/dataservices/metadata">
    <code>InvalidInput</code>
    <message xml:lang="en-US">0:One of the request inputs is not valid.</message>
</error>

I contacted the Azure team about this issue, and they confirmed that it is a limitation that exists, and will be fixed.

The workaround is simple:

You must store one instance of each entity type appearing in an Entity Group Transaction in the table.  So, do this:

    tableServiceContext.AddObject(EntitySetName, new XEntity("Dummy", "DummyX"));
    tableServiceContext.SaveChangesWithRetries();
    tableServiceContext.AddObject(EntitySetName, new YEntity("Dummy", "DummyY"));
    tableServiceContext.SaveChangesWithRetries();

Whenever your table is empty, and then the above example will work.

Best,

Brian

It’s been months since I had anything interesting to blog about.  Mostly because I was working away on some new stuff I couldn’t talk about.  Anyway, now I feel like blogging again.

I’m working on an Azure Worker Role which processes messages from an Azure Queue.  In the main loop of my Worker Role, I had a piece of code like this:

var messageCount = cloudQueue.RetrieveApproximateMessageCount();
for (var i = 0; i < messageCount; i++)
{
    ThreadPool.QueueUserWorkItem(ProcessQueueMessage);
}

Simple enough:  Retrieve the approximate message count and queue up enough work items to process the messages.

Then I thought, “I’m sick of writing stupid for loops!”

So I extended the int type with the following extension method:

/// <summary>
/// Extends int to have a For method.
/// </summary>
/// <param name="value">The int being extended.</param>
/// <param name="action">The Action to execute.</param>
public static void For(this int value, Action action)
{
    for (var i = 0; i < value; i++)
    {
        action();
    }
}

Now, I can write that loop in a single line of code:

cloudQueue.RetrieveApproximateMessageCount().For(() => ThreadPool.QueueUserWorkItem(this.ProcessQueueMessage));

Which is nice!  Love it.

Then I thought, “What if I need to know the ordinal value of the for loop inside the action, though?”

So I extended the int type with another extension method:

/// <summary>
/// Extends int to have a For method.
/// </summary>
/// <param name="value">The int being extended.</param>
/// <param name="action">The Action&lt;int&gt; to execute.</param>
public static void For(this int value, Action<int> action)
{
    for (var i = 0; i < value; i++)
    {
        action(i);
    }
}

So now, I can write:

10.For(i => Console.WriteLine(String.Format("Writing {0}", i)));

And see the following output:

Writing 0
Writing 1
Writing 2
Writing 3
Writing 4
Writing 5
Writing 6
Writing 7
Writing 8
Writing 9

Of course, I’ll want the same extensions for long, etc.  That’ll be simple enough…

Best,

Brian

Read his Maker’s Schedule, Manager’s Schedule essay for what I think is one of the smartest descriptions of the classic problem all programmers face.

Spread this meme in your organization.

Are you a Maker or a Manager?

Both are useful, but they are very different roles.

I am a Maker.  I need two things to be productive:

1. A completely quiet place to work.
2. Vast chunks of totally uninterrupted time.

How simple is that?  Turns out, not so simple.  The forces of evil work to ensure that you almost never get either.

Spread the Maker/Manager meme. 

If you’re a Maker, reject 10 AM, 11 AM, 2 PM, and 3 PM meetings.  Write in your response, “Sorry, I’m a Maker, and this doesn’t work for me.”  When someone asks for a meeting, insist on first thing AM, lunchtime, or last thing PM.  Otherwise, no.  No meeting.

You’re a Maker.  Your needs should be respected.  The Makers of the world shouldn’t have to go home to get their work done because the Managers killed their day.

Best,

Brian

object y = new object();
const int iterations = 10000000;

Which is faster, InterlockedIncrement:

stopWatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
    Interlocked.Increment(ref x);
}
stopWatch.Stop();
Console.WriteLine("Interlocked took " + stopWatch.ElapsedMilliseconds);

Or lock:

stopWatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
    lock (y)
    {
        x++;
    }
}
stopWatch.Stop();
Console.WriteLine("lock took " + stopWatch.ElapsedMilliseconds);

The answer surprised me:

Interlocked took 168
lock took 389

Best,

Brian

Instructions:

Override DisposeResources in derived classes.  When this method is called, always release unmanaged resources, and dispose of managed resources only if the disposeManagedResources parameter is true.

using System;
using System.Threading;

/// <summary>
/// DisposableBase class. Represents an implementation of the IDisposable interface.
/// </summary>
public abstract class DisposableBase : IDisposable
{
    /// <summary>
    /// A value which indicates the disposable state. 0 indicates undisposed, 1 indicates disposing
    /// or disposed.
    /// </summary>
    private int disposableState;

    /// <summary>
    /// Finalizes an instance of the DisposableBase class.
    /// </summary>
    ~DisposableBase()
    {
        // The destructor has been called as a result of finalization, indicating that the object
        // was not disposed of using the Dispose() method. In this case, call the DisposeResources
        // method with the disposeManagedResources flag set to false, indicating that derived classes
        // may only release unmanaged resources.
        this.DisposeResources(false);
    }

    /// <summary>
    /// Gets a value indicating whether the object is undisposed.
    /// </summary>
    public bool IsUndisposed
    {
        get
        {
            return Thread.VolatileRead(ref this.disposableState) == 0;
        }
    }

    #region IDisposable Members

    /// <summary>
    /// Performs application-defined tasks associated with disposing of resources.
    /// </summary>
    public void Dispose()
    {
        // Attempt to move the disposable state from 0 to 1. If successful, we can be assured that
        // this thread is the first thread to do so, and can safely dispose of the object.
        if (Interlocked.CompareExchange(ref this.disposableState, 1, 0) == 0)
        {
            // Call the DisposeResources method with the disposeManagedResources flag set to true, indicating
            // that derived classes may release unmanaged resources and dispose of managed resources.
            this.DisposeResources(true);

            // Suppress finalization of this object (remove it from the finalization queue and
            // prevent the destructor from being called).
            GC.SuppressFinalize(this);
        }
    }

    #endregion IDisposable Members

    /// <summary>
    /// Dispose resources. Override this method in derived classes. Unmanaged resources should always be released
    /// when this method is called. Managed resources may only be disposed of if disposeManagedResources is true.
    /// </summary>
    /// <param name="disposeManagedResources">A value which indicates whether managed resources may be disposed of.</param>
    protected abstract void DisposeResources(bool disposeManagedResources);
}

Best,

Brian

/// <summary>
/// Extends StringBuilder so that it has an AppendFormatLineInvariant method.
/// </summary>
/// <param name="value">The StringBuilder being extended.</param>
/// <param name="format">A composite format string.</param>
/// <param name="args">An object array that contains zero or more objects to format.</param>
/// <returns>The StringBuilder.</returns>
public static StringBuilder AppendFormatLineInvariant(this StringBuilder value, string format, params object[] args)
{
    return value.AppendLine(string.Format(CultureInfo.InvariantCulture, format, args));
}

Best,

Brian

/// <summary>
/// Extends StringBuilder so that it has an AppendFormatLine method.
/// </summary>
/// <param name="value">The StringBuilder being extended.</param>
/// <param name="format">A composite format string.</param>
/// <param name="args">An object array that contains zero or more objects to format.</param>
/// <returns>The StringBuilder.</returns>
public static StringBuilder AppendFormatLine(this StringBuilder value, string format, params object[] args)
{
    return value.AppendLine(string.Format(format, args));
}

So now you can simply code this:

stringBuilder.AppendFormatLine("Here's a line {0}", "YES!");

Instead of:

stringBuilder.AppendLine(String.Format("Here's a line {0}", "YES!"));

Just reads easier, and is simpler to dot through with IntelliSense.

Best,

Brian