blogs.claritycon.com

tfs 2010 RC Agile Process template update – New Task progress report

rpowers — Fri, 12 Mar 2010 19:49:34 GMT

Maybe my next post will just be about why I am so excited and impressed with the out of the box templates. But, for this first blog with my new focus, I thought I would just walk through the process I went through to create a task progress report (to enhance the out of the box Agile template).

So, I started with the MSF for Agile Development 5.0 RC template. After reviewing the template, I came away pretty excited about many of the new reports. I am especially excited about the reporting services reports. The big advantage I see here is that these are querying the Warehouse directly instead of the Analysis Services Cube which means that they are much closer to real-time which I find very important for reports like Burndown and task status. One report that I focused on right away was the User Story Progress Report. An overview is shown below:

This report is very useful, but a lot of our internal managers really prefer to manage at the task level and either don’t have stories in TFS or would like to view this type of report for tasks in addition to the User Stories. So, what did I do?

Step 1: Download the Agile Template

In VS 2010 RC, open Process Template Manager from Team->Team Project Collection Settings. Download the MSF for Agile Development template to your local file system. A project template is a folder of xml files. There is a ProcessTemplate.xml in the root and then a bunch of directories for things like Work Item Definitions and Queries, Reports, Shared Documents and Source Control Settings.

Step 2: Copy the folder

My plan here is to make a new template with all of my modifications. You can also just enhance update the MSF template. However, I think it is cleaner when you start making modifications to make your own template. So, copy the folder and name it with your new template name.

Step 3: Change Template Name

Open ProcessTemplate.xml and change the <name> of the template.

Step 4: Copy the rdl of the Report you want to use a starting point

In my case, I copied Stories Progress.rdl and named the file Task Progress Breakdown.rdl. I reviewed the requirements for the new report with some of the users here and came up with this plan. Should show tasks and be expandable to show subtasks. Should add Assigned To and Estimated Finish Date as 2 extra columns.

Step 5: Walkthrough the existing report to understand how it works

The main thing that I do here is try to get the sql to run in SQL Management Studio. So, I can walkthrough the process of building up the data for the report.

After analyzing this particular report I found a couple of very useful things. One, this report is already built to display subtasks if I just flip the IncludeTasks flag to 1. So, if you are using Stories and have tasks assigned to each story. This might give you everything you want.

For my purposes, I did make that change to the Stories Progress report as I find it to be a more useful report to be able to see the tasks that comprise each story. But, I still wanted a task only version with the additional fields.

Step 6: Update the report definition

I tend to work on rdl in visual studio directly as xml. Especially when I am just altering an existing report, I find it easier than trying to deal with the BI Studio designer. For my report I made the following changes.

Updated Fields
- Removed Stack Rank and Replaced with Priority since we don’t use Stack Rank
- Added FinishDate and AssignedTo
Changed the root deliverable SQL to pull @tasks instead of @deliverablecategory and added a join CurrentWorkItemView for FinishDate and Assigned to

SELECT cwi.[System_Id] AS ID FROM [CurrentWorkItemView] cwi
            WHERE cwi.[System_WorkItemType] IN (@Task)
            AND cwi.[ProjectNodeGUID] = @ProjectGuid

SELECT lh.SourceWorkItemID AS ID FROM FactWorkItemLinkHistory lh
            INNER JOIN [CurrentWorkItemView] cwi ON lh.TargetWorkItemID = cwi.[System_Id]
            WHERE lh.WorkItemLinkTypeSK = @ParentWorkItemLinkTypeSK
                AND lh.RemovedDate = CONVERT(DATETIME, '9999', 126)
                AND lh.TeamProjectCollectionSK = @TeamProjectCollectionSK
                AND cwi.[System_WorkItemType] NOT IN (@DeliverableCategory)

Added AssignedTo and FinishDate columns to the @Rollups table
Added two columns to the table used for column headers

Added Cells for the two new headers
Added Cells to the data table to include the two new values (Assigned to & Finish Date)
Changed a bunch of widths that would change the format of the report to display landscape and have room for the two additional columns
Set the Value of the IncludeTasks Parameter to 1

<ReportParameter Name="IncludeTasks">
      <DataType>Integer</DataType>
      <DefaultValue>
        <Values>
          <Value>=1</Value>
        </Values>
      </DefaultValue>
      <Prompt>IncludeTasks</Prompt>
      <Hidden>true</Hidden>
    </ReportParameter>
Change a few descriptions on how the report should be used

This is the resulting report

I have attached the final rdl.

Step 7: Update ReportTasks.xml

Last step before the template is ready for use is to update the reportTasks.xml file in the reports folder. This file defines the reports that are available in the template.

Step 8: Upload the template

Open the process Template Manager just like Step 1. And upload the new template.

That’s it. One other note, if you want to add this report to existing team project you will have to go into reportmanager (the reporting services portal) and upload the rdl to that projects directory.

Blog Rebranding

rpowers — Fri, 12 Mar 2010 17:20:51 GMT

I have been spending more and more time on learning as much as I can on Agile Development and also have been fairly immersed in rolling out TFS 2010 in our environment. I feel like it is time to talk about some of my experiences. With that, I am rebranding my blog to focus on these topics. I am going to start with a bunch of blogs on the process I have gone through getting TFS 2010 configured for our development teams.

Last week, Brian Harry was in our office and gave a great talk on the improved tools in TFS 2010 and how Microsoft uses the tools internally. I followed that up with a high-level overview of the improved out of the box process templates and the process to customize them. I am definitely very excited about the new features in 2010 and hopefully will keep up my motivation to blog about it. I am writing my first post right now about the process I went through to build a task progress report based on the user story progress report in the MSF for Agile Development template. Stay tuned…

Building KPIs to monitor your business – It’s not really about the Technology

akarcher — Tue, 09 Mar 2010 07:47:05 GMT

When I have discussions with people about Business Intelligence, one of the questions the inevitably come up is about building KPIs and how to accomplish that. From a technical level the concept of a KPI is very simple, almost too simple in that it is like the tip of an iceberg floating above the water. The key to that iceberg is not really the tip, but the mass of the iceberg that is hidden beneath the surface upon which the tip sits.

The analogy of the iceberg is not meant to indicate that the foundation of the KPI is overly difficult or complex. The disparity in size in meant to indicate that the larger thing that needs to be defined is not the technical tip, but the underlying business definition of what the KPI means. From a technical perspective the KPI consists of primarily the following items:

Actual Value – This is the actual value data point that is being measured. An example would be something like the amount of sales.
Target Value – This is the target goal for the KPI. This is a number that can be measured against Actual Value. An example would be $10,000 in monthly sales.
Target Indicator Range – This is the definition of ranges that define what type of indicator the user will see comparing the Actual Value to the Target Value. Most often this is defined by stoplight, but can be any indicator that is going to show a status in a quick fashion to the user. Typically this would be something like: Red Light = Actual Value more than 5% below target; Yellow Light = Within 5% of target either direction; Green Light = More than 5% higher than Target Value
Status\Trend Indicator – This is an optional attribute of a KPI that is typically used to show some kind of trend. The vast majority of these indicators are used to show some type of progress against a previous period. As an example, the status indicator might be used to show how the monthly sales compare to last month. With this type of indicator there needs to be not only a definition of what the ranges are for your status indictor, but then also what value the number needs to be compared against.

So now we have an idea of what data points a KPI consists of from a technical perspective let’s talk a bit about tools. As you can see technically there is not a whole lot to them and the choice of technology is not as important as the definition of the KPIs, which we will get to in a minute. There are many different types of tools in the Microsoft BI stack that you can use to expose your KPI to the business. These include Performance Point, SharePoint, Excel, and SQL Reporting Services. There are pluses and minuses to each technology and the right technology is based a lot on your goals and how you want to deliver the information to the users. Additionally, there are other non-Microsoft tools that can be used to expose KPI indicators to your business users.

Regardless of the technology used as your front end, the heavy lifting of KPI is in the business definition of the values and benchmarks for that KPI. The discussion about KPIs is very dependent on the history of an organization and how much they are exposed to the attributes of a KPI. Often times when discussing KPIs with a business contact who has not been exposed to KPIs the discussion tends to also be a session educating the business user about what a KPI is and what goes into the definition of a KPI. The majority of times the business user has an idea of what their actual values are and they have been tracking those numbers for some time, generally in Excel and all manually. So they will know the amount of sales last month along with sales two years ago in the same month. Where the conversation tends to get stuck is when you start discussing what the target value should be.

The actual value is answering the “What” and “How much” questions. When you are talking about the Target values you are asking the question “Is this number good or bad”. Typically, the user will know whether or not the value is good or bad, but most of the time they are not able to quantify what is good or bad. Their response is usually something like “I just know”. Because they have been watching the sales quantity for years now, they can tell you that a 5% decrease in sales this month might actually be a good thing, maybe because the salespeople are all waiting until next month when the new versions come out.

It can sometimes be very hard to break the business people of this habit. One of the fears generally is that the status indicator is not subjective. Thus, in the scenario above, the business user is going to be fearful that their boss, just looking at a negative red indicator, is going to haul them out to the woodshed for a bad month. But, on the flip side, if all you are displaying is the amount of sales, only a person with knowledge of last month sales and the target amount for this month would have any idea if $10,000 in sales is good or not.

Here is where a key point about KPIs needs to be communicated to both the business user and any user who might be viewing the results of that KPI. The KPI is just one tool that is used to report on business performance. The KPI is meant as a quick indicator of one business statistic. It is not meant to tell the entire story. It does not answer the question “Why”. Its primary purpose is to objectively and quickly expose an area of the business that might warrant more review. There is always going to be the need to do further analysis on any potential negative or neutral KPI.

So, hopefully, once you have convinced your business user to come up with some target numbers and ranges for status indicators, you then need to take the next step and help them answer the “Why” question. The main question here to ask is, “Okay, you see the indicator and you need to discover why the number is what is, where do you go?”. The answer is usually a combination of sources. A sales manager might have some of the following items at their disposal (Marketing report showing a decrease in the promotional discounts for the month, Pricing Report showing the reduction of prices of older models, an Inventory Report showing the discontinuation of a particular product line, or a memo showing the ending of a large affiliate partnership. The answers to the question “Why” are never as simple as a single indicator value.

Bring able to quickly get to this information is all about designing how a user accesses the KPIs and then also how easily they can get to the additional information they need. This is where a Dashboard mentality can come in handy. For example, the business user can have a dashboard that shows their KPIs, but also has links to some of the common reports that they run regarding Sales Data. The user’s boss may have the same KPIs on their dashboard, but instead of links to individual reports they are going to have a link to a status report that was created by the user that pulls together all the data about the KPI in a summary format the user’s boss can review.

So some of the key things to think about when building or evaluating KPIs for your organization:

Technology should not be the driving factor
KPIs are of little value without some indicator for whether a value is good, bad or neutral.
KPIs only give an answer to the “Is this number good\bad?” question
Make sure the ability to drill into the “Why” of a KPI is close at hand and relevant to the user who is viewing the KPI.

The KPI is a key business tool when defined properly to help monitor business performance across the enterprise in an objective and consistent manner. At times it might feel like the process of defining the business aspects of a KPI can sometimes be arduous, the payoff in the end can far outweigh the costs. Some of the benefits of going through this process are a better understanding of the key metrics for an organization and the measure of those metrics and a consistent snapshot of business performance that can be utilized across the organization. And I think that these are benefits to any organization regardless of the technology or the implementation.

Invisible OCS conference participants

mgreenlee — Sun, 21 Feb 2010 19:18:34 GMT

Many of you, since encountering OCS 2007 R2 and its trusty sidekick server-side API, UCMA 2.0, have been wondering, “How do I spy on people and secretly record their audio conferences?”

Luckily for you, to complement its delightfully straightforward automation of SIP messaging, UCMA 2.0 has a rich array of covert operations functionality.

That may be a slight exaggeration. What it does provide is a way for server-side applications to perform a “trusted conference join.” A UCMA 2.0 application running as a trusted service which has authenticated with the OCS server by means of a certificate can join a conference invisibly, meaning it does not show up in the roster of conference participants.

Although I was tempted to title this article “Wiretapping in UCMA 2.0,” the trusted conference join feature has many uses. It allows you to create applications that provide services to OCS conferences without causing distracting and tacky-looking bots to appear in the list of participants. Some examples:

Recording conversations for auditing, monitoring, or training purposes
Conference timekeeping for businesses that bill by the minute
Piping music or audio announcements into a conference
Silent monitoring of conferences for training purposes
Scaring people in a conference by suddenly saying something when they didn’t know you were there

So how do you do it?

First of all, your application needs to be using an application endpoint rather than a user endpoint. User endpoints cannot join conferences as a trusted participant.

When you call the BeginJoin method on the ConferenceSession object to join a conference, you can supply a ConferenceJoinInformation object with the URI of the conference you want to join. This ConferenceJoinInformation object also has a property called IsTrustedJoin. When this property is set to true, your application endpoint will join the conference as a trusted participant.

Let’s say you are joining a conference that has already started, and you have the conference URI stored in a local variable. You would do something like this:

// Create a ConferenceJoinInformation object with the conference URI
ConferenceJoinInformation joinInfo = new ConferenceJoinInformation(
    new Microsoft.Rtc.Signaling.RealTimeAddress(conferenceUri)
);

// Make this a trusted join
joinInfo.IsTrustedJoin = true;

// Create a new conversation 
conversation = new Conversation(_applicationEndpoint);

// USe the conversation to join the conference
conversation.ConferenceSession.BeginJoin(joinInfo,
    result =>
    {
        conversation.ConferenceSession.EndJoin(result);
    },
    null
);

First, you create a new instance of ConferenceJoinInformation, passing in the conference URI. In order for the constructor to like it, you need to turn the string that contains the URI into a RealTimeAddress object.

Next, you set the IsTrustedJoin property to true.

Finally, you create a new conversation and call the BeginJoin method, passing in the join information.

When the asynchronous operation completes, your application will be a participant in the conference, sending and receiving media like any other, but it will be INVISIBLE.

There is one other point I want to call out here before concluding. If you want to have more than one of these invisible participants from the same application (e.g. one to record and one to make animal noises) you can do this, on two conditions: you will need to create a Conversation object for each participant, and you will need to impersonate a fake URI so that the participants have different URIs.

To do this, you use the Impersonate method on the Conversation object, as below:

// Create a new conversation with impersonation
conversation = new Conversation(_applicationEndpoint);
conversation.Impersonate("RandomSounds@____________.com", "tel:+15555551212", "Random Sounds");

The URI you use can be completely fabricated; it doesn’t need to be a real contact.

This technique can be especially handy when combined with a back-to-back user agent (B2BUA) to proxy remote users into a conference invisibly. More on this in a future post if there is interest.

I take no responsibility for any imprudent or illegal things you do with trusted conference participants!

Putting Down Time

pmiller — Sun, 21 Feb 2010 04:43:29 GMT

In my last post I discussed how some creative thinking on my part led me to redo large chunks of a task scheduling library. As promised, here are some of the major changes and what I learned from them.

Lush Verbiage

In the refactor, I expanded upon the concept of a timekeeper and extended the metaphor to the rest of they component. So a timekeeper, keeps time, or in this case, a timetable. A timetable is composed of entries, a combination of time slot and actions scheduled for that time. A timekeeper has a worker which “works” the timetable using a simple procedure. Find the next entry in the timetable, keep track of the passage of time until it is past that entry’s time, execute the actions for that entry, find the next entry, continue on.

The metaphor is strained at times, but by carefully choosing descriptive names for classes from the physical world, there was less mental friction when trying to implement or explain the component.

Design Simplicity

Dealing with time based code in .NET is harder than it should be. Or more accurately, harder then I’d want it to be. Even the conceptually simple idea of scheduling a task to happen every hour is fraught with peril. I started with a Timer that went off at the next hour and repeated with a period of 60 minutes. This mostly works, but that timer will sometimes fire before the hour is up. Only a fraction of a second before the hour, but that is time enough to wreck havoc on logic that looks for the next event chronologically or on other components that depend on the hourly events occurring on or after the hour. If not havoc, at least make it messier.

Ultimately, I could have gotten past that challenge, but I decided to simplify the code by making the main “tick” loop of the timekeeper (what looks for timetable entries that need to be executed) a brute force style thread.sleep, check, thread.sleep, check, loop. The idea of this approach grates on me as it is making the program spin more then it needs to, but a sleep of 100 ms was enough to not noticeably affect CPU utilization. In addition, this made it very easy to add support for a clean stop of the timekeeper worker:

internal class TimekeeperWorker : BackgroundWorker
    {...

protected override void OnDoWork(DoWorkEventArgs e)
{...

while (!CancellationPending)
          {
              Thread.Sleep(100);

… “tick” loop logic

}
           //cancellation pending, so exit out
           e.Cancel = true;

Even after this latest refactor, there are more places I could simplify this code. However, just like optimization, there is an effort associated with simplification that isn’t always needed. At least not yet.

Daylight Savings Time

This is kind of a subset of Design Simplicity, but one of the concerns I had with this component was how it would handle Daylight Savings Time. When the clock jumps from 1:59AM to 1AM or 3AM for example. After some discussion with the team, the behavior we decided on was that in the case of jumping back, the timekeeper would fire the 1AM action twice, jumping forward, the timekeeper would fire the 3AM action, skipping any 2AM actions.

With that expectation set, how to implement that? I debated using the TimeZone and TimeZoneInfo classes to get to the DaylightTime objects and figure that all out. After scratching my head over that for a while without making headway, I decided to again take a bit of a brute force approach in that timekeeper worker’s “tick” loop:

              Thread.Sleep(100);
              timeNow = TimekeeperClock.Now();
              if ( Math.Abs( (timeNow - lastTime).Ticks ) > TimeSpan.FromMinutes(1).Ticks)
              {
                  //if the time changes more then one minute (plus or minus)
                  //after a 1/10 of a second sleep, then
                  //we've had some kind of major clock adjustment 
                  //(potentially daylight savings time)
                  //so recalculate what the next entry would be
                  //have to back up the time a bit, in case it went from 
                  //1:59:59am to 3:00:01am on dst change
                  _logger.InfoFormat("Clock drift detected from {0} to {1} in one cycle.",
                       lastTime, timeNow);
                  DateTime lookBackTime = timeNow.Add(TimeSpan.FromMinutes(-1));
                  _logger.InfoFormat("Recalculating next entry based on a time of {0}",
                         lookBackTime);
                  _next = _timetable.GetNextEntry(lookBackTime);
              }

The worker knows the last time it got from the clock, so if the next time it gets is significantly different, something has happened. The worker assumes it is a daylight savings time adjustment and recalculates the next timetable entry from the new time. In order to actually catch the hour changing, that next entry is actually calculated from the new time minus a minute. A bit goofy, but workable, and easier then dealing with the .NET time zone classes.

Testing Time

Testing time based code is tough. I found it useful to just let the component run for days in our test environment and watch the log, but that’s not particularly efficient. So I wrote some automated tests for the timekeeper, for example, to test that the daylight savings time behavior was what I wanted:

[Test]
       public void Should_Execute_One_AM_Task_Twice_On_Jump_Back_DST()
       {
           var tt = new Timekeeper();
           int numberTimesExecuted = 0;
           var incrementTimesExecuted = new Task
           {
               Execute = dt =>
               {
                   numberTimesExecuted += 1;
                   return new TaskResult { Message = "Incremented" };
               },
               FriendlyName = "Increment Times Executed"
           };
           tt.ScheduleFor(new TimeSpan(1,0,0), incrementTimesExecuted);
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 0, 59, 59);
           tt.Start();
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 1, 0, 01);
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 1, 59, 59);
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 1, 0,01);
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           Assert.AreEqual(2, numberTimesExecuted);
           tt.Stop();
       }

       [Test]
       public void Should_Execute_One_AM_And_3_AM_And_Not_2_AM_Task_On_Jump_Forward_DST()
       {
           var tt = new Timekeeper();
           List<int> hoursExecuted = new List<int>();
           var addHourToExecuted = new Task
                                            {
                                                Execute = dt =>
                                                              {
                                                                  hoursExecuted.Add(dt.Hour);
                                                                  return new TaskResult();
                                                              }
                                            };

           tt.ScheduleForEveryHour(addHourToExecuted);
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 0, 59, 59);
           tt.Start();
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 1, 0, 01);
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 1, 59, 59);
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           TimekeeperClock.Now = () => new DateTime(2010, 3, 14, 3, 0, 01);
           System.Threading.Thread.Sleep(200);//let timekeeper tick
           Assert.Contains(1, hoursExecuted);
           Assert.Contains(3, hoursExecuted);
           Assert.False(hoursExecuted.Contains(2));
           tt.Stop();
       }

Pretty, these are certainly not. The lowlights include the numerous thread.sleep calls, which allow the timekeeper’s background worker to catch up and notice that the time has changed. The inline definition of tasks also ends up taking up a lot of screen real estate. Finally, the setting of method local variables from the action delegates seems clunky.

With all that said, these tests do make me feel more confident that the timekeeper will behave as expected, and furthermore express the expected behavior of the component to anybody else who reads them.

The reliance on using thread sleeps really bothers me; so far the only way around it that I could think of was to extract the main loop logic from worker into a pluggable algorithm, that is passed into the timekeeper as a dependency. Then I could test just that dependency in isolation. To put flesh on that, I’d have a property or constructor argument on the timekeeper that was an interface with a method that takes in the last known time, and a reference to the timetable, and then calculates what if anything to execute based on the current time.

Wrapping Up

This has been fun for me, and fixing up this component will be valuable to my current project in helping us reduce our day to day support load. I also got more experience with unit testing, and some experience using git to put the code up on github. Hopefully you learned something along the way as well. If you think this code would be useful to you (or part of it), check it out at http://github.com/phmiller/Timekeeper. And thanks for reading this far <g>

--- Relevant Links ---

The post wasn’t lengthy enough for you? Maybe try a dead-tree book, like Kent Beck’s XP Explained (2nd edition). Well worth your time:
http://www.amazon.com/Extreme-Programming-Explained-Embrace-Change/dp/0321278658/ref=dp_ob_title_bk

Brian Harry – Microsoft Technical Fellow – Speaking at Clarity Consulting

gdurzi — Fri, 19 Feb 2010 01:08:06 GMT

Join us on Thursday, March 4th from 3 pm - 6 pm for Visual Studio 2010 and Team Foundation Server 2010, presented by Microsoft Technical Fellow, Brian Harry.

Attend this event to learn more about Microsoft’s vision for developer team solutions. Brian will cover the key advances for developers in Visual Studio 2010 and Team Foundation Server 2010.

Attendees will have an opportunity to ask Brian Harry questions around Microsoft’s vision for developer tools and platforms. This is a great opportunity to connect directly with a very senior and technical developer community leader within Microsoft.

Ryan Powers from Clarity Consulting will also discuss how Clarity’s project teams use Team Foundation Server as part of the software development lifecycle.

Registration and more details.

Time Again: Creative Destruction

pmiller — Thu, 18 Feb 2010 05:20:00 GMT

In the collection of interviews, Coders At Work, a common theme was the idea that when confronted with a difficult debugging problem, it can be better to just redo the troubled code rather then fix it.

This may seem like an invitation to put on your cape and do some hero-programming. This kind of creative destruction is only warranted when you are confident you can reproduce the functionality more coherently and with fewer bugs in less time than it would take to fully understand and tweak the existing code.

As I mentioned in a previous post, I’ve been working on a component to keep time and schedule tasks. The basic requirements of which are:

Keep time in any time zone
Provide a way to schedule tasks for every hour change, day change or arbitrary time
Provide a mechanism to monitor the results of these tasks and/or any exceptions

The implementation I described in that post mostly worked, but would occasionally just fall over in our test environment. I couldn’t find the bug and looking through the code, I saw a lot of room for improvement. So after some creative destruction, I had a new and cleaner implementation:

public interface ITimekeeper
  {
      Action<Task, Exception> ExceptionHandler { get; set; }
      Action<Task, TaskResult> CompletedHandler { get; set; }
      void ScheduleFor(TimeSpan timeOfDay, Task task);
      void ScheduleForEveryDay(Task task);
      void ScheduleForEveryHour(Task task);
      void Start();
      void Stop();
  }

public class Task
   {
       public Func<DateTime, TaskResult> Execute { get; set; }
       public string FriendlyName { get; set; }
   }

public class TaskResult
   {
       public bool Error { get; set; }
       public string Message { get; set; }
   }

Even just from a usage perspective this code reads much nicer to me:

var tk = new Timekeeper("Central Standard Time");
tk.ScheduleForEveryHour(task1);
tk.ScheduleForEveryHour(task2);
tk.ExceptionHandler += 
  (task, ex) => System.Console.WriteLine(
      "[Exception Handler] Exception for {0}: {1}", 
      task.FriendlyName, ex);
tk.CompletedHandler += 
  (task, result) => System.Console.WriteLine(
      "[Completed Handler] {0} completed with a message of {1}", 
      task.FriendlyName,result.Message);
tk.Start();

Under the hood, the changes were pervasive, and we’ll look at those changes in an upcoming post.

--- Relevant Links ---

Coders At Work was a fascinating read for the insights into how some of the giants of our field work. The homepage is also notable for an excellent salmon background:
Coders At Work Homepage

Can’t wait for the next post? Want to take a look at the code for yourself? View at your own risk:
Timekeeper on Github

Code Snippetry: C# Asynchronous Actions

pmiller — Sat, 13 Feb 2010 22:38:46 GMT

For the time keeping component that I’ve mentioned before, one of the requirements was that it be able to run multiple actions or tasks at a given point in time. In case some of these tasks were particularly long running the idea was to run them in the background, rather than potentially block the main thread and miss a subsequent scheduled time. We also wanted to keep track of a task failing to execute properly and report back on that.

C# 3.0 provides some elegant and concise ways to do this. My exact implementation was pretty particular to our problem space, but for blogging’s sake, I abstracted out a basic and version of it for your convenience.

We’ll start from the top with usage:

    class Program
    {
        static void Main(string[] args)
        {
            int i = 0;
            List<Action> actionsToExecuteAsync = new List<Action>() 
            {
                () =>  System.Console.WriteLine("executed action 1"),
                () =>  System.Console.WriteLine("executed action 2"),
                () =>  System.Console.WriteLine("exception time: {0}", 1/i),
                () =>  System.Console.WriteLine("executed action 4")
            };
            AsyncUtil.ExecuteAsync(actionsToExecuteAsync, HandleException);
            System.Console.ReadLine();
        }

        static void HandleException(Exception e)
        {
            System.Console.WriteLine("exception: {0}", e);
        }
    }

There is a heavy helping of syntactic sugar here as I create some anonymous delegates (Action’s) to execute and put them in a list using a collection initializer. Next up I call the ExecuteAsync method and wait to see the results. Which look something like this:

executed action 1
executed action 2
executed action 4
exception: System.DivideByZeroException: Attempted to divide by zero.
at AsyncWorker.Program.<>c__DisplayClass8.<Main>b__3() in C:\Users\Peter\src\
AsyncWorker\AsyncWorker\Program.cs:line 17
at AsyncWorker.AsyncUtil.<>c__DisplayClass3.<ExecuteAsync>b__0(Object state)
in C:\Users\Peter\src\AsyncWorker\AsyncWorker\AsyncUtil.cs:line 20

So we’ve got our tasks executing and an exception in one of them being handled by the HandleException method.

Looking behind the curtain:

public static class AsyncUtil
{
    public static void ExecuteAsync(List<Action> actions, Action<Exception> exceptionHandler)
    {
        foreach (var action in actions)
        {
            var actionToExecute = action;
            ThreadPool.QueueUserWorkItem(state =>
            {
                try
                {
                    actionToExecute();
                }
                catch (Exception e)
                {
                    exceptionHandler(e);
                }
            }, null);
        }
    }
}

Almost more whitespace and curly braces in there then code, but that won’t stop us. Again, with some sugary syntax, I’m throwing the action to a background thread through the call to ThreadPool.QueueUserWorkItem.

A gotcha was that I have to create the actionToExecute variable to ensure that all threads don’t just execute the last action in the list. Why? Because each thread would get a reference to “action” (from the foreach loop) and by the time they executed, “action” would be the final item in actions. Which is probably more confusing to you then it would be if you just took this code and tried it with and without the extra variable.

So take it for what it’s worth, but I found this snippet of code to be useful and a pleasant reminder of how expressive you can be in C#.

---Relevant Links---

If you care to learn anything about threading in .NET, read this whole threading guide by Joseph Albahari:
http://www.albahari.com/threading/

If you want to see what’s coming in .NET 4.0 that makes this even easier and more powerful:
http://www.codethinked.com/post/2010/01/25/NET-40-and-SystemThreadingTasks.aspx

Json in .NET

kmarshall — Fri, 05 Feb 2010 21:22:17 GMT

I use Json all the time, but I feel like it’s super annoying in .NET. Typically I’d call some web service that returns Json. In .NET it seems like the best thing to is to define a data contract and use the DataContractSerializer:

[DataContract]
public class Person
{
    [DataMember]
    public string FirstName { get; set; }

    [DataMember]
    public string LastName { get; set; }
}

then to deserialize whatever string of Json I got back. .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

public static Person DeserializeToPerson( string jsonString )
{
   using( MemoryStream ms = new MemoryStream( Encoding.Unicode.GetBytes( jsonString ) ) )
   {
      DataContractJsonSerializer serializer =
         new DataContractJsonSerializer( typeof( Person ) );
      return ( Person )serializer.ReadObject( ms );
    }
}

Feels like a lot of code and I need to define the data contract beforehand which seems a little unnecessary given the dynamic nature of web services and Json. Things like the the memory stream reader and getting bytes off the string are brutal. Why can’t i just pass a string to the JsonDataContractSerializer? Some things seem way more complicated in .NET than they need to be. (cref: Calling REST services in .NET)

What I’d like is something closer to Python.

import simplejson as json
person = json.loads(jsonString)
print person.FirstName

That is pretty easy.

With .NET there are some options like:

System.Json

var data = JsonObject.Load(dataStream);  
Console.Writeline(data["FirstName"])

.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

This is pretty close to what I want. The problem is having to cast sub items to things like JsonArray and what not. Secondly, System.Json only works in Silverlight so i can’t use in a web project or desktop app.

Next option is one of the Json libraries like Json.Net. Not that I mind using any 3rd party DLLs, I just think parsing Json is fairly common if you are calling a rest web service and it should be in the framework, maybe I’m the only one that uses json all the time instead of XML but I’d rather use Lotus Notes everyday than parse XML and you know I hates the Lotus Notes.

This site has an interesting approach: http://blog.petegoo.com/archive/2009/10/27/using-json.net-to-eval-json-into-a-dynamic-variable-in.aspx

2 problems for me. I still need to reference Json.Net and there is that ridiculous looking code to convert to Expando object. I just don’t feel comfortable dropping that blob in my code.

Ideally Json parsing would be something similar but handled in the framework:

dynamic person = JsonObject.Load(jsonString)
Console.Writeline(person.FirstName)

That makes me happy. No pre-defining a contract and something in the framework that can take a string of Json and return back a dynamic object. There is so much stuff in the .NET framework, why can’t there be useful helpers that do common tasks like this.

I could totally be missing simpler solutions so feel free to chime in if I’m just an idiot and missing something obvious.

Upcoming TechEd and MSDN Events in the Midwest Region

gdurzi — Fri, 05 Feb 2010 13:58:00 GMT

I volunteer for INETA as the user group mentor for the Midwest Region (IL, IN, and WI). One of the things I'm planning to do differently this year is to better help spread the word on my blog about events happening in the region, whether they're Microsoft or user group organized and hosted.

If your user group is hosting an event such as a code camp, send me a short write up and some photos and I'll make sure it gets published in the INETA newsletter.

Back to business ... Here's some info about some Azure and Visual Studio 2010 events that are coming up:

TechNet Events Present:  Windows Azure, Hyper-V and  Windows 7 Deployment - 8:30am – 12:00pm
Get the inside track on new tips, tools and technologies for IT pros. Join your TechNet Events team for a look at Windows Azure™ and learn the basics of this new online service computing platform. Next, we’ll explore how to build a great virtual environment with Windows Server® 2008 R2 and Hyper-V™ version 2.0. We’ll wrap this free, half-day of live learning with a tour of easy deployment strategies for Windows® 7.

TOPICS INCLUDE:
    •    The Next Wave: Windows Azure
    •    Hyper-V: Tools to Build the Ultimate Virtual Test Network
    •    Automating Your Windows 7 Deployment with MDT 2010

Date	Location/Registration
2/10/2010	Lombard, IL
3/9/2010	Waukesha, WI
3/11/2010	Indianapolis, IN

MSDN Events Presents: Cloud Computing and Azure - 1:00pm – 4:30pm
Join your local MSDN Events as we take a deep dive into cloud computing and the Windows Azure Platform.

TOPICS INCLUDE:
    •    What is cloud computing?
    •    Running web and web service applications in the cloud
    •    Using the Windows Azure and local developer cloud fabric
    •    Getting started – tools, SDKs and accounts
    •    Writing applications for Windows Azure

Date	Location/Registration
2/10/2010	Lombard, IL

MSDN Events Presents: Visual Studio 2010, .NET Framework 4.0 and SharePoint Development - 1:00pm – 4:30pm
Join your local MSDN Events team for a lively tour our latest version of Visual Studio and the .NET Framework. We’ll start with an overview the IDE and explore how you can use the latest features to develop great applications in a flash. Next, we’ll look at the newest changes to the .NET Framework and how you can leverage them today. Finally, we end the day by looking at the new tools in Visual Studio that will supercharge your SharePoint development.

TOPICS INCLUDE:
    •    What’s new in Visual Studio 2010
    •    What’s new in .NET Framework 4.0
    •    SharePoint Development using Visual Studio 2010

Date	Location/Registration
3/9/2010	Waukesha, WI
3/11/2010	Indianapolis, IN

Surface Apps on Windows 7

kmarshall — Thu, 04 Feb 2010 15:10:47 GMT

I feel like an idiot for not realizing this sooner, but if you have the Surface touchpack for Win7, you can reference those Microsoft.Surface.Touchpack dlls in your Surface app, remove the regular Surface references and change the namespaces and voila, your Surface app runs on Win 7. How did I not know this sooner? That seems fairly awesome to me. Surface apps running on the 3m 10-touch capacitive screen are fantastic.

Random Ideas for Mobile Advertising

kmarshall — Thu, 04 Feb 2010 14:24:33 GMT

Here are things I’ve been thinking about lately in regards to mobile advertising.

Mobile advertising seems really underdeveloped. Maybe in part because it’s difficult to tailor ads to various devices and it’s easy to push the standard banner ad inventory or just punt on originality and buy Google ad words. (side note – who actually clicks on google ads? how does this make money for anyone? they seem so worthless)
Local advertising also seems fairly weak. What replaces local business ads in local papers once they all die out? It doesn’t seem effective for those businesses to buy google ad words. The geographic targeting seems limited and again, who clicks on those ads. There seems to be room for someone to come in and dominate advertising on the local level similar to what google did with online ads in general. Make it super easy and cheap for local businesses to display ads to people that are within a given radius of their business.
My ideal mobile advertising scenario is close to what Foursquare has done. I check-in at one venue and it alerts me of specials nearby. Although it’s pretty basic in Foursquare. It seems like it could be way more targeted. I check-in at a bar and it could present offers for drink specials at the bar next door. I love the market that could develop for bidding on what gets displayed when you check-in at certain venues. (Side note – I really want to see sponsored badges on Foursquare seems like a great revenue model. Bonus points if the foursquare app handles mobile payments to track actually getting those badges. Pay for 10 lattes with the foursqaure app, get the latte lover badge)

Ad words and banner ads just seem lazy. Want to target rich people? put a banner ad on forbes. Want to target people who like to ski? buy an ad word for “ski”

Here is what I want in ads:

Contextual relevant – This is the whole reason facebook ads are worthless. Just because I like books by Michael Chabon, doesn’t mean I want to see an for his book. I probably already have it and most likely I was just browsing someone’s drunken party pics so I was too distracted to notice the ad anyway.
Engaging not just distracting – There are a lot of talented agencies out there, do something good. Make me want to experience the ad instead of just clogging up the intertubes and my screen with your 120x240 animated gif.
Demographically relevant – I like that Hulu let’s me choose. I’d rather watch the Smirnof ad than the trailer for the new Sex & the City movie. (Bonus points to Hulu for recognizing that if you show me a 10 second ad instead of 3 mins, I will actually pay attention because it’s not enough time for me to leave the room)
Geographically focused – I see ads for Sonic on TV sometimes. I want that slushy and tater tots shown. There is no Sonic in San Francisco. That makes me sad. This shouldn’t happen.
Value Added – Mint does this well. I don’t mind seeing credit card or bank ads because they are presented in a helpful manner and again are contextually relevant. The same ad for a “no limits platinum joie de vivre” card shown on espn.com just pisses me off and ad block is going to boot it off my screen

Mobile advertising seems like it could knock all these out. I’m out shopping, I check-in at the Extra Big & Tall show me an ad for a sale on husky fleece pants at Old Navy next door. Maybe include multiple product photos or a little video. You can even scan the ad when i purchase said husky fleece pants to complete the feedback loop. Contextually relevant – I’m shopping, Engaging – some multi-media action, Demographically relevant – I’m a big guy who like comfy pants, Geographically focused – It’s for the store next door and it adds value – I saved some money or you sold me on something I didn’t think I even needed.

Is this too much to ask for? I submit no. Stop wasting time on this pennies per billion impression non-sense. Advertisers should be able to get much higher ROI on ads and I shouldn’t have to be inundated with crap. Ads are always going to be a reality, let's just make them not suck so much.

Kindle App Idea #1

kmarshall — Thu, 04 Feb 2010 13:44:16 GMT

I’m thinking I’ll just start blogging the random ideas I have. Maybe they are good and i will eventually do it or maybe someone else will and I reap the benefits or maybe they suck and nothing happens. Either way, I get a +1 on my blogging stats.

I love my kindle and I think the demise of e-Ink in favor of reading on a tablets is overrated. The Kindle app store seemed like an obvious idea. Amazon clearly needs to grow the device and lots of people are unwilling to pay $200+ for a device that “just reads books” Not that there is anything wrong with that. Plus they can charge other people for apps without actually having to think of new uses for the Kindle themselves. Well played Amazon.

So idea #1. Facebook on the Kindle. Not original right? I don’t want a Facebook client because I rarely use Facebook anymore. The one really useful thing I like about Facebook is Facebook Connect. I really just want my list of friends and their data. I want the Kindle Facebook app to prompt me for a review after I finish a book and post that to Facebook. Then I want to be able to browse books my friends liked and click to buy. I read a fair amount of books and I’m always interested in recommendations. There are bunch of social book sites out there, but I hate having to enter stuff manually. The Kindle knows when I finish a book so I’d like to just take care of it then automagically. Cross posting the review to Amazon would be nice because I value the ratings on there, but I don’t have “friends” on Amazon so there isn’t an easy way to see what they recommend.

I have no idea what the SDK allows though. It would be great if there was some OnBookCompleted event that you could attach apps to. Also it’s Java and the thought of using Java again makes Kevin the Coder cower in fear. Maybe someone can get JRuby or Jython running on there.

That or it could just tweet the books I read automatically because you really can’t overshare enough on Twitter.

Experimenting with inter-role communication on Azure for caching

kmarshall — Thu, 04 Feb 2010 12:25:00 GMT

It’s been awhile since I’ve used Azure. The new storage libraries are a welcome addition. As a better diagnostic framework and inter-role communication. In a previous Azure project, I wanted to use ASP.NET caching on the web role, but that breaks down if you start to run multiple instances. With inter-role communication it seems like you could use caching on the server as long as you notify the other instances of updates to the cache. I wrote a little prototype to do that. It’s fairly basic and I haven’t tested it on a real deployment or benchmarked etc. Basically this may just be a terrible way of doing things.

First I defined a contract for the cache messages:

   1:  using System.Collections.Generic;

   2:  using System.ServiceModel;

3:

   4:  namespace MvcWebRole1.Caching

   5:  {

   6:      /// <summary>

   7:      /// Defines the contract for the cache service.

   8:      /// </summary>

   9:      [ServiceContract]

  10:      public interface ICacheService

  11:      {

  12:          [OperationContract(IsOneWay = true)]

  13:          void Insert(string key, object value);

14:

  15:          [OperationContract(IsOneWay = true)]

  16:          void Remove(string key);

  17:      }

  18:  }

Next I implemented the service for that contract.

   1:  using System;

   2:  using System.Web;

   3:  using System.Diagnostics;

   4:  using System.Linq;

   5:  using System.ServiceModel;

   6:  using System.Threading;

   7:  using Microsoft.WindowsAzure.Diagnostics;

   8:  using Microsoft.WindowsAzure.ServiceRuntime;

9:

  10:  namespace MvcWebRole1.Caching

  11:  {

  12:  /// <summary>

  13:      /// Implementation of the WCF cache service.

  14:      /// </summary>

  15:      [ServiceBehavior(

  16:          InstanceContextMode = InstanceContextMode.Single,

  17:          ConcurrencyMode = ConcurrencyMode.Multiple,

  18:  #if DEBUG

  19:          IncludeExceptionDetailInFaults = true,

  20:  #else

  21:          IncludeExceptionDetailInFaults = false,

  22:  #endif

  23:   AddressFilterMode = AddressFilterMode.Any)]

  24:      public class CacheService : ICacheService

  25:      {

  26:          public void Insert(string key, object value)

  27:          {

  28:              HttpRuntime.Cache.Insert(key, value);

  29:              Trace.TraceInformation(String.Format("Added: {0} to key: {1} from broadcast", value, key));

  30:          }

31:

  32:          public void Remove(string key)

  33:          {

  34:              HttpRuntime.Cache.Remove(key);

  35:              Trace.TraceInformation(String.Format("Removed key: {0} from broadcast", key));

  36:          }

  37:      }

  38:  }

That handles the inserts / deletes the cached items when one instance broadcasts a cache update.

The next bit of code is used to cache on one instance and then broadcast that info out to the other roles.

   1:  using System;

   2:  using System.Diagnostics;

   3:  using System.Linq;

   4:  using System.ServiceModel;

   5:  using System.Threading;

   6:  using System.Web;

   7:  using Microsoft.WindowsAzure.Diagnostics;

   8:  using Microsoft.WindowsAzure.ServiceRuntime;

9:

  10:  namespace MvcWebRole1.Caching

  11:  {

  12:      public class SynchedCache

  13:      {

  14:          private enum BroadcastType

  15:          {

  16:              Insert,

  17:              Remove

  18:          }

19:

  20:          public static void Insert(string key, object value)

  21:          {

  22:              HttpRuntime.Cache.Insert(key, value);

  23:              Trace.TraceInformation(String.Format("Added: {0} to key: {1}", value, key));

  24:              BroadcastCacheUpdate(BroadcastType.Insert, new object[] {key, value});

  25:          }

26:

  27:          public static void Remove(string key)

  28:          {

  29:              HttpRuntime.Cache.Remove(key);

  30:              Trace.TraceInformation(String.Format("Removed key: {0}", key));

  31:              BroadcastCacheUpdate(BroadcastType.Remove, new object[] { key });

  32:          }

33:

  34:          public static object Get(string key)

  35:          {

  36:              return HttpRuntime.Cache.Get(key);

  37:          }

38:

  39:          private static void BroadcastCacheUpdate(BroadcastType type, params object[] args)

  40:          {

  41:              // iterate over all instances of the internal endpoint except the current role - no need to notify itself

  42:              var current = RoleEnvironment.CurrentRoleInstance;

  43:              var endPoints = current.Role.Instances.Where(instance => instance != current)

  44:                              .Select(instance => instance.InstanceEndpoints["InternalHttpIn"]);

45:

  46:              foreach (var ep in endPoints)

  47:              {

  48:                  EndpointAddress address =

  49:                      new EndpointAddress(String.Format("http://{0}/InternalHttpIn", ep.IPEndpoint));

  50:                  ICacheService client = WebRole.Factory.CreateChannel(address);

51:

  52:                  try

  53:                  {

  54:                      string key = args[0].ToString();

55:

  56:                      switch (type)

  57:                      {

  58:                          case BroadcastType.Insert:

  59:                              client.Insert(key, args[1]);

  60:                              break;

61:

  62:                          case BroadcastType.Remove:

  63:                              client.Remove(key);

  64:                              break;

  65:                      }

66:

  67:                      ((ICommunicationObject)client).Close();

  68:                  }

  69:                  catch (TimeoutException timeoutException)

  70:                  {

  71:                      Trace.TraceError("Unable to notify web role instance '{0}'. The service operation timed out. {1}",

  72:                          ep.RoleInstance.Id, timeoutException.Message);

  73:                      ((ICommunicationObject)client).Abort();

  74:                  }

  75:                  catch (CommunicationException communicationException)

  76:                  {

  77:                      Trace.TraceError("Unable to notify web role instance '{0}'. There was a communication problem. {1} - {2}",

  78:                          ep.RoleInstance.Id, communicationException.Message, communicationException.StackTrace);

  79:                      ((ICommunicationObject)client).Abort();

  80:                  }

  81:              }

  82:          }

  83:      }

  84:  }

Finally in your page you can perform operations on the cache like so.

SynchedCache.Insert(key, DateTime.Now.ToString());.csharpcode, .csharpcode pre
{
	font-size: small;
	color: black;
	font-family: consolas, "Courier New", courier, monospace;
	background-color: #ffffff;
	/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt 
{
	background-color: #f4f4f4;
	width: 100%;
	margin: 0em;
}
.csharpcode .lnum { color: #606060; }

That call will then notify all the other web roles running. Of course running AppFabric Caching on Azure would be a much better solution once available, but the inter-role communication is still nice to have for other stuff.

High Attention, Low Distraction

pmiller — Thu, 04 Feb 2010 05:17:47 GMT

Truly paying attention can be one of the hardest things to do. Even when you are doing something you want to do, say solving an interesting problem, your mind flits about. In a five minute interval you might answer an IM, check your email, check twitter and oh yeah, think about that problem you are working on.

There is a lot of literature out there around “flow” and the efficiency of focusing your attention on just one task. If you are working as an engineer or implementer on a project, common ways to help reduce these distractions are to put up a red flag (physically or with a do not disturb online status) or put on your headphones. You can also try to increase your focus by self imposing time boxes on your schedule, a la the Pomodoro Technique of 25 minute bursts of concentrated activity.

That’s at an individual level. To keep a software team focused, I’ve learned by counter example that the key is for the team to be highly focused on the smallest number of tasks you can get away with. Again, this is not easy to accomplish, but Agile methodologies have a lot to say on this.

From agile in general, comes the phrase “done done.” Meaning work on a task until the code works, is documented, tested, builds and deploys smoothly. This requires extra discipline on the part of the developer as making the code work is the fun part, whereas the rest just seems like extra effort. This also requires discipline on the part of the team lead to allow this “extra” work to be completed when the developer could go on to make something else work. The benefit is you don’t have to backtrack as much or have a stressful big bang at the end of a cycle to do all your integration, building, testing and documenting.

“Done done” talks about how to work on a task, which doesn’t help if you are overloaded with too many. Scrum addresses this problem through sprint planning, where tasks are given estimates and only X amount of work is allowed into a sprint. This should result in fewer tasks per developer, but not always. Again, discipline is the key as the scrum master and product owner have to engage in a give and take to keep scope manageable. If the product owner says you have to do everything this sprint, no matter what, you aren’t doing agile anymore, you’re just fire fighting.

Kanban or lean methodologies, deriving from production environments, focus on limiting the number of tasks going on at once. Every task goes through distinct stages and a new task cannot be added until another task exits the last stage. Progress is tracked visually on a kanban board. So there are not really sprints, so much as a continuous low flow of focused activity. I haven’t done kanban myself, but like scrum, it implies a give and take between the team and the other stakeholders to understand that doing less at once, does mean doing less for the project lifecycle.

So while Agile is becoming mainstream, and the concept of flow is almost passé at this point, I don’t get the sense that it is mainstream to follow through on their convergence of focusing more on fewer items at a time. This seems to be a general trend, where we all like the idea of being Agile, but think a light process = a free and easy process. After a rather unsuccessful attempt at Scrum with that concept in my mind, I can assure you it is not the case. Good process is difficult, but when did difficulty ever stop us before?

--Relevant Links--

The Pomodoro Technique and tomato timers:
http://www.pomodorotechnique.com/

If you like “Done done”, check out:
http://en.wikipedia.org/wiki/Buffalo_buffalo_Buffalo_buffalo_buffalo_buffalo_Buffalo_buffalo

More on “done done”:
http://blog.phpdeveloper.org/?p=148

InfoQ’s stuff is pretty good, haven’t read this yet myself, but looks promising:
http://www.infoq.com/minibooks/kanban-scrum-minibook

Agile is now mainstream:
http://www.computerworld.in/articles/agile-software-development-now-mainstream

Stumbling Through – Clearing Test K2 Data

tbyrne — Wed, 27 Jan 2010 18:38:54 GMT

In many K2 projects I've worked on, we end up having to tie existing business data into the various workflow processes. While k2 provides a means to do this via process/activity data fields, they tend to be difficult to query against and can be inefficient compared to an existing schema that has been optimized specifically for the business data involved. That, and why store the same data twice if it already exists in a database? That discussion is not the point of this blog entry, though it is an interesting topic that I may revisit later. For now, lets roll with the assumption that we have data in a custom database that is related to K2 process instances.

During development and testing cycles, one of the tedious activities for me has been trying to clean up old test data, particularly when there are thousands of process instances involved. The reason for this is because cleaning data in the scenario described above is a two-step process: First delete the custom database data and then delete the K2 process instances. Deleting the custom database data is no problem - write a quick SQL script and run it as needed but cleaning the K2 process instances is a different story...

There are two main ways to clear K2 process instances: via API or via Workspace. While we could write a program that would execute our database clean up scripts and then iterate through and delete our K2 process instances via API, but that is too much work for this ~~lazy~~ busy developer. The workspace approach can be a real hassle when there are thousands of process instances because let's face it - deleting more than 100 process instances at a time is not a snappy experience through today's workspace.

After wrestling with clearing test data repeatedly through the workspace, I finally posed myself the question: Why is it that we can't we delete process instances through the same SQL script we use to clear the custom data? Surely, the workspace uses some sort of stored procedure(s) when it deletes a process instance, right? I started digging around through the K2 databases to see if any stored procedures jumped out at me as obvious choices and while there were a few likely candidates, none of them fit the bill. Frustrated, I posed the question on the K2Underground and was quickly directed to an article that came close to what I was trying to accomplish. Using the code in this article as a base, I tweaked it until it was capable of clearing all process instances for a given folder (could easily work for a given process name as well) and it has been so useful to me that I figured I'd share it here. Be warned, this is slapped together for development assistance, and should by no means be used on a production box! Happy data clearing...

/*
Delete all workflow process instances
*/
Use K2Server
DECLARE @FOLDERNAME VARCHAR(100)
SET @FOLDERNAME = '[Enter Folder Name Here]'

PRINT 'Starting to remove Process Instances for ' + @FOLDERNAME

PRINT 'Getting List of Process Instances'
SELECT ID INTO #TMP FROM _ProcInst
WHERE PROCID IN
(
    SELECT ID
    FROM _PROC
    WHERE PROCSETID IN
    (
        SELECT ID
        FROM _PROCSET
        WHERE FOLDER = @FOLDERNAME
    )
)

PRINT 'Removing Process Instances from _IPC'
DELETE _IPC
FROM _IPC
INNER JOIN #TMP
ON SrcProcInstID = #TMP.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _IPC'

PRINT 'Removing Process Instances from _ProcInst'
DELETE _ProcInst
FROM _ProcInst
INNER JOIN #TMP
ON _ProcInst.ID = #TMP.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ProcInst'

PRINT 'Completed removing completed process instances from K2ServerLog for folder ' + @FOLDERNAME

DROP TABLE #TMP

Use K2ServerLog

PRINT 'Starting to remove Process Instances for ' + @FOLDERNAME

PRINT 'Getting List of Process Instances'
SELECT ID INTO #TMP2 FROM _ProcInst
WHERE PROCID IN
(
    SELECT ID
    FROM _PROC
    WHERE PROCSETID IN
    (
        SELECT ID
        FROM _PROCSET
        WHERE FOLDER = @FOLDERNAME
    )
)

PRINT 'Removing Process Instances from _ActInst'
DELETE _ActInst
FROM _ActInst INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInst'

PRINT 'Removing Process Instances from _ActInstAudit'
DELETE _ActInstAudit
FROM _ActInstAudit
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInstAudit'

PRINT 'Removing Process Instances from _ActInstDest'
DELETE _ActInstDest
FROM _ActInstDest
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInstDest'

PRINT 'Removing Process Instances from _ActInstDestData'
DELETE _ActInstDestData
FROM _ActInstDestData
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInstDestData'

PRINT 'Removing Process Instances from _ActInstDestDataAudit'
DELETE _ActInstDestDataAudit
FROM _ActInstDestDataAudit
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInstDestDataAudit'

PRINT 'Removing Process Instances from _ActInstDestXml'
DELETE _ActInstDestXml
FROM _ActInstDestXml
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInstDestXml'

PRINT 'Removing Process Instances from _ActInstDestXmlAudit'
DELETE _ActInstDestXmlAudit
FROM _ActInstDestXmlAudit
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInstDestXmlAudit'

PRINT 'Removing Process Instances from _EscInst'
DELETE _EscInst
FROM _EscInst
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _EscInst'

PRINT 'Removing Process Instances from _EventInst'
DELETE _EventInst
FROM _EventInst
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _EventInst'

PRINT 'Removing Process Instances from _IPC'
DELETE _IPC
FROM _IPC
INNER JOIN #TMP2
ON SrcProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _IPC'

PRINT 'Removing Process Instances from _LogBatch'
DELETE _LogBatch
FROM _LogBatch
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _LogBatch'

PRINT 'Removing Process Instances from _LineInst'
DELETE _LineInst
FROM _LineInst
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _LineInst'

PRINT 'Removing Process Instances from _ProcInst'
DELETE _ProcInst
FROM _ProcInst
INNER JOIN #TMP2
ON _ProcInst.ID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ProcInst'

PRINT 'Removing Process Instances from _ProcInstAudit'
DELETE _ProcInstAudit
FROM _ProcInstAudit
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ProcInstAudit'

PRINT 'Removing Process Instances from _ProcInstData'
DELETE _ProcInstData
FROM _ProcInstData
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ProcInstData'

PRINT 'Removing Process Instances from _ProcInstDataAudit'
DELETE _ProcInstDataAudit
FROM _ProcInstDataAudit
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ProcInstDataAudit'

PRINT 'Removing Process Instances from _ProcInstXml'
DELETE _ProcInstXml
FROM _ProcInstXml
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ActInst'

PRINT 'Removing Process Instances from _ProcInstXmlAudit'
DELETE _ProcInstXmlAudit
FROM _ProcInstXmlAudit
INNER JOIN #TMP2
ON ProcInstID = #TMP2.ID
PRINT CAST(@@ROWCOUNT AS VARCHAR(10)) + ' records removed from _ProcInstXmlAudit'

PRINT 'Completed removing completed process instances from K2ServerLog for folder ' + @FOLDERNAME

DROP TABLE #TMP2

More About Time: Leveraging Castle Windsor

pmiller — Wed, 20 Jan 2010 14:00:00 GMT

In a previous post, I mentioned working on a time keeping component. We used this component as the basis of a task scheduling application. Our tasks were represented by classes that implemented a common task interface:

 
public interface ICustomTask
{
   CustomTaskResult Execute();
   DateTime? ExecutionTime { get; }
   TimeZoneInfo ExecutionTimeZone { get; }
   string Description { get; }
}

public class CustomTaskResult
{
    public bool WasSuccess { get; set; }
    public string Message { get; set; }
}

So far, so good. Next challenge was how do we specify which of these tasks to run, and when? My initial thought was to put these details in an app.config or custom XML file. Task elements with the class name and time as attributes for example. Then additional elements for custom parameters that a task might need to initialize.

Fortunately enough, I work with some smart people, one of whom gently suggested that rather then create and manage my own custom config file, I instead leverage Castle Windsor (our dependency injection framework) and its configuration.

I’ll let the code do the talking; here’s a windsor section of an app.config for our task scheduler which will run two tasks at 9pm and the end of every day (the default if no time is specified) respectively:

<castle>
   <components>
       <component id="NightlyProcessing" lifestyle="transient" 
         service="Clarity.ICustomTask, Clarity.Task" 
         type="Clarity.Processing.NightlyTask, Clarity.Processing">
		<parameters>
		     <timeZone>Eastern Standard Time</timeZone>
	              <processingTime>9:00 PM</processingTime>
		  </parameters>
       <component id="RunSSISPackage" lifestyle="transient" 
	service="Clarity.ICustomTask, Clarity.Task" 
	type="Clarity.SSIS.PackageTask, Clarity.SSIS">
       <parameters>
         <description>Nightly Data Archiving</description>
          <pathToPackage>c:\Data_Archive.dtsx</PathToPackage>
          <pathToConfigFile>C:\DEV.dtsConfig</PathToConfigFile>
        </parameters>
      </component>
   </components>
</castle>

The namespaces have been sanitized, but the point is that you can specify parameter elements that map to constructor arguments. So for example, the NightlyTask class has a constructor with a timeZone and processingTime argument that get mapped to the ExecutionTime and ExecutionTimeZone properties on the custom task.

--- Relevant Links ---

To take this to the next level (or if you just don’t like the angle bracket tax):

http://sheitm.blogspot.com/2009/05/fluent-castle-windsor-and-configured.html

Utilizing Custom Fonts with SQL Reporting Services (SSRS) and Exporting to PDF

akarcher — Mon, 18 Jan 2010 08:41:08 GMT

I recently had a unique challenge with SSRS which was the utilization of a Custom Font on an SSRS Report. Normally, I do not think about fonts other than what get installed as system fonts in Windows so this was a fairly new experience. I know a few people who REALLY enjoy fonts in the Design Practice at Clarity, but had never considered the impact and usefulness they can play in SSRS. It was somewhat difficult to find information about this so I figured I would summarize to save some other people some trouble.

The report that I had to develop was going to be a customer facing report so there were some fairly exact standards that it needed to comply with both from an aesthetic and regulatory perspective, much more so than most SSRS reports which are generally for internal consumption only. As an idea of some of the requirements take a look at a statement from your cell phone provider, local utility or television provider, and that is similar to what I had to build. If you have never looked very closely at something like that you probably have missed the sheer amount of different fonts, font sizes, font weights, font decorations, and so on that is used in building that statement. Some of the formatting is done based on aesthetics and some is also based on regulations, such as minimum font sizes for those disclaimers that you can barely read on the statement.

So before I get into the nuts and bolts of this, I need to give a shout out to Andre Milbradt from the SSRS team who was very helpful in clearing up some of the confusion out there for me on font embedding and the PDF Renderer.

Before we get into SSRS, let’s go into a bit about the different types of fonts out there (Reminder: I am not a Font guy). There are two major types of Fonts out there: True Type (wiki: http://en.wikipedia.org/wiki/True_Type_Font ) and Open Type (wiki: http://en.wikipedia.org/wiki/OpenType). Of these two, SSRS fully supports True Type Fonts and has limited support for Open Type Fonts. Essentially, any Font that can be instantiated by the .Net System.Drawing.Font (http://msdn.microsoft.com/en-us/library/system.drawing.font.aspx) class is supported by SSRS. Because the custom font that we needed was available as both a True Type Font and an Open Type Font, we went with the True Type font since we knew that it would be fully supported.

So we went ahead and installed the fonts on the developer machine and the SSRS server. On the development machine, you do have to restart Visual Studio after you install the fonts for Visual Studio to pick up on the font. On the server, we were having issues with SSRS picking up the newly installed Font until we restarted the Reporting Services Server. We probably could have just restarted SSRS, but we ended up just restarting the server. If you have never installed a font before (I hadn’t before this project) you can get to the installed fonts by going to Control Panel -> Fonts. For Windows XP and above you can just copy and paste the font files into this directory. For Vista and above, one of the right-click options on the .ttf font file is “Install”.

I first started developing the report in SSRS 2005, using my custom font and it all looks good. Then I try to export to PDF for the first time and “Uh-Oh”. That doesn’t quite work. And after a bit of research and some verification from the PG team, SSRS 2005 does have limited support PDF Font Embedding, but it is limited to Unicode Data. You can check out the Books Online here (http://technet.microsoft.com/en-us/library/ms159713(SQL.90).aspx) about the behavior in SSRS 2005. You can also check out this post from Robert Bruckner (http://blogs.msdn.com/robertbruckner/archive/2008/10/27/unicode-in-pdf-font-embedding.aspx ) on the feature in SSRS 2008 CU1, which is the same feature that was also added SSRS 2005 in SP3. So since I was using ANSI text data, it was on to SSRS 2008.

So I started looking at Books Online for SSRS 2008 and noticed the same restrictions on Font Embedding in PDF as there are in SSRS 2005. If you take a look at the same topic for SSRS 2008 (http://technet.microsoft.com/en-us/library/ms159713(SQL.100).aspx) in the Font Embedding section it still lists the following as a restriction, “The characters in the string that has the Font property set are Unicode, not ANSI. No font embedding occurs for ANSI characters.” After confirmation from the product group, this is incorrect and a User Education bug was submitted to have this documentation fixed. So with that out of the way and we had confirmation that SSRS 2008 will embed fonts within a generated PDF, we developed our report.

At this point I want to remind you to restart the server after installing your font, because I forgot my own rule to restart the server after installing fonts and was pulling my hair out at one point.

So after you have developed and deployed your report, you export to PDF and want to verify that your Font got embedded. There are a number of ways to do this. First, check the properties of the PDF. In Acrobat Reader, go to File->Properties and then click on the Font tab. There should be a listing of Fonts there which should include your custom font. Second, send the PDF to someone who does not have the Font installed. They should see the new custom font as well in their PDF. Lastly, if your custom font is not obvious, having a nice trained designer eye is the best tool you can have to verify the font for you.

So hopefully this post clears up some confusion on custom fonts and Font Embedding with the PDF Font Renderer.

Agile in Action – TDD Lessons Learned

pmiller — Sat, 16 Jan 2010 15:46:39 GMT

As I continue to explore agile techniques at work, I had the opportunity to do some Test Driven Development, specifically Test First Development. The problem at hand was that our system is composed of several applications, all of which have various actions they have to take every hour or every day at a specific time. As the applications were developed, each application grew out its own time keeping infrastructure.

If you haven’t had the pleasure yet, working with time, dates and durations in .NET is not as easy as you’d like. It has gotten a lot better since framework 1.0, but it is still a great place for bugs to hatch. And not surprisingly, while each application was able to implement a system that worked most of the time, the code base was sprawling and behavior was unpredictable.

With the hindsight that comes after pushing a system to production, my team became convinced that we needed more then working most of the time, we wanted to prove that it worked all the time. Also, having abused the coding principle of (D)on’t (R)epeat (Y)ourself with multiple competing implementations we wanted to settle on one common implementation.

The approach we took was to throw out the old code, and first define an interface for our time keeper. Now it looks something like this:

 public interface ITimekeeper
 {
        event EventHandler HourChanged;
        event EventHandler DayChanged;

        void Initialize(TimeZoneInfo timeZone, DateTime dayChangeTime);
        void RegisterCustomEvent(DateTime time, TimeZoneInfo timeZone, 
					CustomEventCallback callback, object state);
        void Start();
        void Stop();
	...

	IClock Clock { get; set; }
}

Now is an important qualifier. We didn’t start out with the right interface, we took an educated guess and then started writing some tests. Importantly, and somewhat surprisingly to me, we got a lot of value out of just trying to write the tests themselves. It was a feedback loop as we’d try to write a test, find the interface clunky, refine the interface , write the test again and then move on.

We deliberately ignored the implementation at first and defined a reasonably wide set of tests that covered the basic functionality of our component. Then we subjected the interface to its sharpest critique by handing these tests off to another developer on the team and having him implement the code to make them pass.

In short, TDD drove our component level design to be more elegant, provided a natural way to break out tasks amongst the team, and of course provided us some confidence that the implementation would work.

I think I am taking a break from the bold prediction business, but this experience definitely has lead me to reconsider some of the points made over a year ago in this post of questionable origin:

http://blogs.claritycon.com/blogs/peter_miller/archive/2008/10/06/why-test-driven-development-is-a-hard-sell.aspx

<--- A questionable dude…

--- Related Links ---

Hat tip to Philipp Sumi, who implemented a nice scheduling library of his own (which I found after I finished my efforts) and provided me some good feedback and insight on TDD.

http://www.hardcodet.net/2010/01/lightweight-task-slash-job-scheduling-with-silverlight-support

Also, for the eagle eyed amongst you, yes we do have an interface for the system clock, IClock. See Ayende Rahien’s post on why this seeming non sequitur can be useful:

http://ayende.com/Blog/archive/2008/07/07/Dealing-with-time-in-tests.aspx

Making Visual Studio and Dependency Injection Play Nice

pmiller — Fri, 15 Jan 2010 03:56:11 GMT

Dependency injection (DI) is a powerful technique to make your code more testable and your application more adaptable to future changes. Working with an application that uses DI in Visual Studio can be painful. You want to be able to make changes to your dependencies, and have those changes automatically picked up and put in the right place, so that when your application tries to find them, it uses the latest version. And you want that all to happen just when you press F5 to debug.

I posted a question to stackoverflow.com about this, laying out some options, including copying files by hand or creating a post build event per dependency per application. In keeping with stackoverflow rules about open ended questions, I quickly marked an answer as accepted.

The answer I accepted was to change the output directories of the dependency projects to some common folder, which the application would then query for dependencies at runtime:

This sounded good, but after some thought, I was worried about the unintended consequences of having these projects not build to the normal bin/debug, bin/release folders.

After some experimentation, I ended up with a solution that is similar in spirit, but leaves the normal build output directory alone:

Add post build events to each dependency project to copy the dll and pdb files to a common directory
1. xcopy $(TargetDir)*.dll $(SolutionDir)diBin /iy
  xcopy $(TargetDir)*.pdb $(SolutionDir)diBin /iy
Add a post build event to the application project to copy the DI dll and pdb files to a subdirectory of its bin
1. xcopy $(SolutionDir)\diBin\*.dll $(TargetDir)diBin\ /iy
  xcopy $(SolutionDir)\diBin\*.pdb $(TargetDir)diBin\ /iy
We use Castle Windsor for DI and to see the dependency files in diBin\ I had to add this to the app.config:
1. <runtime>
      <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
           <probing privatePath="diBin"/>
     </assemblyBinding>
  </runtime>

All of the projects in our solution live one level below the solution, and all are solutions are in the same folder, so $(SolutionDir) is common.

So far this has worked well. This does NOT solve anything having to do with deployment, but it does make the F5 debug experience much nicer.

Relevant Links:

Stack Overflow: How do I get a smooth debug experience in visual studio 2008 when using dependency injection?

MSDN documentation on the probing element

We’re Hiring!

jdsmith — Wed, 13 Jan 2010 15:51:52 GMT

Ever wondered what it would be like to work for a fast-paced, award-winning consulting firm in Chicago? You’re in luck! We’re looking for a few exceptional people.

We’re generally less concerned with specific tool/language experience and more interested in a person’s interest and proven ability to learn new tools and languages. That said, most of our candidates have several years’ experience developing software and most have worked with the .NET Framework and/or web development technologies in previous positions.

The majority of our openings are for full-time Consultant positions. Our Consultants wear many hats but are chiefly responsible for application design, development and deployment. Lots of opportunities for advancement.

Interested? Please send resumes to janet-at-claritycon-dot-com.

You can find more info on our career page!

Agile in Action - A Touch of Pair Programming

pmiller — Sun, 10 Jan 2010 18:41:00 GMT

As a consultant, I am pulled in two seemingly opposing directions in regards to new technology. To be a good consultant, particularly at my company Clarity, you have to be engaged with technology. Reading, talking about, working with new technology is what keeps us fresh and relevant. Here I'm using technology to mean more then just languages or libraries, I also mean the processes and techniques of delivering quality software solutions. The "opposing" force I mentioned earlier is that we have to focus relentlessly on delivering the particular project we're on, with its particular timelines and constraints.

So while I constantly am tinkering with technology in my spare time, I have a much higher bar for what I'd include in my project work. For every upside something new promises, I have to decide if it outweighs the downside or risk to the project. With that said, for the past six months plus, I've been working in product development, so outside the context of my regular on site, client engagement. Our team still cares about the quality of our deliverable, but there is more freedom to experiment with new technology. Using my expanded definition of technology, our team has been experimenting with the new (to us) technology of agile processes.

One of these processes is pair programming. Unfortunately, to the skeptic, a process where two people work together on the same machine on the same task, probably brings the following images to mind:

The Guy Driving

The Other Dude

This is a mistaken view. First off, having worked previously in corporate IT, I can assure you that people are quite capable of doing nothing all day all by their lonesome. Second, we all value pair programming. Don't believe me? Think about what you do when you are working on a particularly nasty bug or making a big architectural decision. You don't usually do that alone, you bring in at least one other trusted person to help out, to bounce ideas off of. I've over simplified here, this is not what agile adherents really mean by pair programming. As an agile practice, pair programming is the predominant mode of work for developers. What I just described is just plain old collaboration. Nevertheless, it is important to point out that the argument is not about whether or not two people working together produce better results, it is about how often they should work together.

Within our product team, we have not moved to pair programming for every task. But we have been using it more extensively then I have before. We've found it surprisingly effective over the past few weeks. In pair programming sessions each lasting a few hours, I and another team member were able to quickly get two components going from design to implementation. I was thrilled with the give and take as we reined in, revised and rejected each others' ideas as necessary. By the end of it, I was mentally worn out, but in a good, kind of post work out muscle burn type of way.

With some hindsight, I think the key to this success was that we were truly peer programming, not just pair programming. There was no project role hierarchy to make one of us hesitant to correct the other, we have similar levels of tech skills and experience so we could keep up with each other and perhaps most importantly we respected each other. Respect means we take each other seriously and actually think about what the other one is saying or coding. This level of engagement helps both sides of the pair get more of out of the experience. Lack of respect plus malice is contempt, which obviously will not work well, but even lack of respect without dislike is often expressed as indifference or pity. Neither one is going to help the pair be more productive then its parts.

Moving forward, I plan to use pair programming more often within our team. I am not ready to take the leap and say we should use it all the time. Part of the software development life cycle always involves some drudgery, linking up simple UI's, writing DB scripts, fixing a simple bug and the like. These tasks might be more pleasant with a partner, but the possible gains in efficiency seem minimal.

Relevant Links

http://xprogramming.com/xpmag/whatisxp#pair

http://menloinnovations.com/blog/?p=399

http://stackoverflow.com/questions/291630/does-pair-programming-work

Speaking at the Central Illinois SharePoint User Group on 1/21/2010

gdurzi — Tue, 29 Dec 2009 16:53:00 GMT

I'll be speaking at the Central Illinois SharePoint User Group in Springfield, IL at 9:00AM on Thursday, January 21st 2010.

The topic will be Building Communications Enabled Applications with OCS and Exchange:

Office Communications Server 2007 R2 and Exchange 2010 enable the development of communication enabled applications more quickly and easily than ever before. In this session you will learn about the core features included in the new platform SDKs and see a demo application built around a retail enterprise that utilizes each of the scenarios the platform enables. You will also learn about opportunities for integrating OCS and Exchange into your SharePoint applications.

More details on location and registration areavailable at https://www.clicktoattend.com/invitation.aspx?code=144377

Clean & Simple Control Styles for SILVERLIGHT 3

eklimczak — Mon, 21 Dec 2009 23:23:49 GMT

I’ve been seeing a bunch of XAML based control skins for WPF and Silverlight lately and I can’t say I’m in love with any of them. I was glad to see that the latest version of the SL toolkit has some additional skins available, but again, I couldn’t see myself ever using the “Bubble Creme” or “Shiny Red” theme for a real client project. Inspired by the “Simple Styles” post by Robby Ingebretsen, I wanted to create a small set of styles that aren’t overly complicated but communicate a simple elegant look and feel. Here at Clarity we put a ton of thought into creating clean and effective user interfaces so I thought I would share some of our techniques for accomplishing just that.

What does Clean & Simple Mean?

Clean User Interface design is typically characterized by a few consistent color choices, clear layout, and as few lines as possible. And a set of nice control styles can go a long way in achieving a design that is complete and beautiful, not cluttered or overbearing. Well designed control styles and skins are typically minimal in nature. In other words, Minimalist design can be described as basic and stripped of superfluous elements, colors, shapes and textures. For example, I think the controls below on the left (from the Silverlight toolkit) are relatively “over designed” with excessive gradients and shiny textures. On the other hand, the controls on the right (from Adobe Lightroom) have clean lines, color, and little texture and communicate the purpose of the control effectively.

How Do I Simplify My Design?

Designing a clean and minimal skin isn’t hard, but takes some trial and error before you get it “just right”. Like I said earlier, well designed controls typically have little texture, color, shape and lines. However, if you go too minimal the design becomes boring and incomplete. To ensure that you are on the right path, keep in mind three fundamentals: Be Mindful of Whitespace, Alignment, and Contrast. After applying these principles, take it a step further and try to take out everything that is unnecessary. Aside from the aforementioned basics, experimenting with different color combinations, atypical layout and interesting typography can help enhance the design while keeping it unique.

Whether I’m designing a UI for an interactive display, digital display board, website, or desktop application I usually get started by:

Look for inspiration - There are tons of resources out there for creative inspiration. Some I use are:

http://www.designmeltdown.com/default.aspx

http://veerle.duoh.com/blog

http://www.designshard.com/

Pick a color scheme – I usually try to stick with a base of three colors (Primary, Secondary, Accent)

http://kuler.adobe.com

http://www.colourlovers.com/

http://colorblender.com/

Choose a font – I usually keep a watchful eye for elegant, readable fonts. Then I use WhatTheFont to help me track it down.

Building the UI

Below is a zoomed out view of a couple styled controls. The important thing to notice is that the clickable regions look beveled and the right combination of lines create an “inset” look where appropriate.

If we zoom in to 1200% we can see the anatomy of the button consists of three borders and a subtle gradient fill. There aren’t any crazy multi-stop gradients or rasterized images used to create the beveled or inset effects…just rectangles and careful choice of color.

This technique of strategically placing lines to create subtle UI effects isn’t new. In fact there are tons of examples done in Flash found all over the web and even in the windows and mac operating systems. The iPhone, Palm-pre, Adobe CS4, Garage Band, are just some examples of precise well-executed control styles.

For this post I choose Silevrlight 3 for demonstration purposes, but the design principles are technology agnostic and can be applied to any digital medium. If you are interested in getting started with control styling specifically in Silverlight 3, it would probably be a good idea to read up on using Resources, Control Templates, and the Visual State Manager in Blend. I hope my post will be helpful in at least getting people started with creating their own elegant UI themes.

You can download the source for the above example HERE

VIDEO PROTOTYPING | A cost-effective and timely approach to application demonstrations.

blamb — Mon, 21 Dec 2009 18:35:00 GMT

When developing multi-touch applications we are often asked for a demonstration of how the final design solution is going to look and feel… or sometimes we just have a stellar idea that we need to share with everyone now! How do you accurately convey a complete user experience without building the entire application? Design mockups and storyboards alone are not going to cut it; they aren’t the most effective tools for communicating user interaction. When faced with a tight timeline or budget, our solution for rapid prototyping is video.

Demo Video vs Video Prototype
Although I recommend giving in person demos of your applications sometimes that just isn’t possible. Videos are a great substitute for in-person demos and in the age of You-Tube and Vimeo you have a much larger opportunity for reaching your target market. After an application is built we make a demo video highlighting the best features of the application by filming a user interacting with the application. A voiceover further describes the details of the application.

Example of one of our demo videos, The Gift Registry Surface Application

You can see more of our demo videos at www.claritycon.com/work/claritytv/

The differentiating factor between the two is that prototyping requires the use of video as a design tool. Video is a fast way to visualize ideas and concepts without the need to spend endless hours developing an entire application. This method allows us to make simulations of real user interface functionality with simple equipment we have in-house.

Smoke and Mirrors
Video is a powerful tool, use it to your advantage. You are not bound to the limitations of technology, with green screens and compositing software the possibilities are endless. This process will let you explore new ways of interaction with software, hardware and technologies that don’t exist yet. If you think this method would be useful in your design process I have put together a HOW TO.

How to Make a Video Prototype
Materials: Green screen material or basic green construction paper, adhesive (double sided tape works well), scissors, finished design mockups, camera, tripod, lights (main and fill), and after effects or equivalent. You will need basic knowledge of video editing and color keying, if you don’t its easy to pick up.

	#1 Setup Select your hardware. If you don’t have what you need be resourceful. For the project I will show we took apart a touch screen monitor, mounted a credit card swipe, a finger print scanner, and a tag reader (none of which actually worked together).
	#2 Green Screen Cut the green paper to the size of your screen and secure it to the screen with adhesive. Make sure there are as few as possible wrinkles or folds in the paper (you don’t want any shadows). If your surface is completely flat you may be able to get away with not using any adhesive.
	#3 Lighting Set up in an area that is well lit or preferably light the device yourself with the conventional 2 or 3 light setup. Lighting is very important when using green screen techniques. There should be no shadows on your green screened surface.
	#4 Interface Print out or sketch a large version of your mockup interface, it should be roughly the size of the green screened interface. Use this to set to the side for visual cues. This is helpful for making gestures and accurate selections on your interface. Make sure your print-out/sketch is not in your shot when filming!
	#5 Storyboards Have your demo flow or user scenarios worked out before you start filming. Storyboards are great for this! Do a few practice runs using the green screen like it is a real life interface to work out gestures and any timing issues. It is helpful if you self narrate your demo. It keeps you from going too fast and you can keep it in the video or dub it out and record a cleaned-up version post-production.
	#6 Using the Camera Set up your camera and film the demo at a straight-on angle. Repeat the same demo using a left or right-side angle. Multiple angles will provide you with plenty of footage for cuts and transitions. It doesn’t hurt to get an establishing shot of the environment as well as close-up shots of the application. Always use a tripod or some method of stabilizing the camera. Aim for shooting in HD if you can, it allows more room to scale and pan your footage while editing.
	#7 Audio Recording Sound can create a more immersive user experience. Record your sound effects, voice-over, or any other audio you may need for your prototype. Audacity is a great tool for audio recording. Remember that audio is a reusable asset and may be recycled for any future projects.
	#8 Compositing Import video clips, audio, and Illustrator/Photoshop mockups into After Effects or other compositing software program. Your mockups should be organized by layers and named accordingly to make them easier to import. Edit your footage into sequence. Animate the mockups and sync audio to match the filmed interactions. Compose the live footage with the animated mockups, keying out the green. Finished example of a video prototype: Blockbuster Checkout Experience

Benefits

Low cost, time efficient, and easy to do
Allows you to consider the environment/setting
Test out user scenarios that are limited by current technology
Visualize design solutions with real interactions
Identify design issues before any development occurs
Learn new methods that are outside your realm of experience

Limitations

Few reusable assets

What are you waiting for… Lights. Camera. Action!