The work done using the team subscription included uploading many gigabytes of sysprepped Virtual Machine images that would stand as the template for scaling up a set of services.  Once the client subscription was in place, we knew we would need to move the images over.

We were a little concerned that moving between subscriptions would take a long time.  Moving between containers isn’t hard, but could you rely on the same mechanism to move between subscriptions?  Turns out the answer is yes if you make the blob or container public during the move.

After you pull in your Azure Subscription into PowerShell (we used Import-AzurePublishSettingsFile) you can do this pretty easily.

Here’s an example of the Posh to do this with a public to private blob using the Azure PowerShell Cmdlets:

In the beginning things are generally amazing.  There’s a new level of transparency, excitement and shared motivation.  At some point, though, the question always comes up: Are we ready to ship?

This is the moment where organizations either head down the Scrum-erfall path or learn what Agile was meant to be:

…satisfy the customer
through early and continuous delivery
of valuable software.

The Path to Scrum-erfall

Unfortunately, too many organizations have taken hold of the rules and ceremonies of Kanban, Scrum, XP, and the rest, but ignore these two principles:

• Working software is the primary measure of progress.
• Deliver working software frequently, from a couple of weeks to a couple of months, with a
  preference to the shorter timescale.

Does Shipping Heal All Wounds?

On March 4th, I opened what I hope will replace the State of Agile report: Release Cadence Report.

This survey and publication was created to refocus our industries attention back on shipping software frequently to the delight and benefit of our customers, team members, and companies.  It is an attempt to relieve our software developers of ineffective anecdotal stories of Facebook and Flickr shipping dozens of times per day.  Instead I want you to have the evidence to take to leaders in your organization so that you can have a serious conversation about the implications of release cadence.

Please take 10 minutes and complete this survey and you will receive an early copy of the report.

Take the Survey

You can also get yourself or your organization listed as being part of this movement by referring your coworkers, peers, friend.  Sign up here and be a part of bringing shipping back to Agile.

Service Bus 1.0 is available only through Web Platform Installer at this time and it’s not readily apparent how you might use WPI for a network isolated environment.  Hopefully this will help:

WebpiCmd.exe to find the Service Bus AppId

Web Platform Installer comes with a command line tool called WebpiCmd.exe.  With it you can list and install packages.  You can also create an offline WPI feed which is what we’ll do.

To list available products at the default Microsoft feed:

webpicmd /List /ListOption:Available

Somewhere in that mess is Service Bus 1.0 and it’s AppId which we’ll need to create a private, offline cache of the product and it’s dependencies.  I’m using Console2 with a PowerShell tab so I can do this:

webpicmd /List /ListOption:Available | ? { $_.Contains(“Service Bus”) }

Since WebpiCmd is just writing dumb lines of text, I can’t interrogate the Product attributes, so I’m using the where-object, aliased to ?, to see which line contains the string “Service Bus”.  WebPI really should be a better PS citizen.

Creating an Offline Feed

WPI works against feeds, so we’re going to create our own feed just for this product.  You might maintain a growing list of products in this feed, but that’s beyond this post.  To create your offline feed we’ll use the (drum roll) /Offline option:

WebpiCmd.exe /offline /Products:ServiceBusBeta /Path:C:\wpi-offline

NOTE: The Service Bus 1.0 entry in WPI seems like it has a problem with the App Fabric dependency.  I’m told that’s fixed now.

Installing from the Offline Feed

Once everything is resolved and downloaded, you can use it with WPI GUI or WebpiCmd.exe. 

You can not automate-all-the-things with:

webpicmd /install /Products:ServiceBus /xml:c:\wpi-offline\feeds\latest\webproductlist.xml

Or do the GUI thing by checking out WPI options:

Scrum (n): A framework within which people can address complex adaptive problems, while productively and creatively delivering products of the highest possible value.

Mario Čop, in his feedback, suggests problems cannot be adaptive.  He provides some definitions of his own to remove the subjective influences around the words “adapt”, “adaptive” and “problem.”  In the end, Mario says:

I’d say that the process of solving problems can be adaptive. When solving problems you can have adaptive approach and adaptive execution of it, but it makes no sense saying that problems itself are adaptive.

Whether successfully conveyed or not, the intent is that complex problems are not always clearly understood.  As we approach and attempt to solve a complex problem, our understanding of that problem becomes clearer.  What this means is that as we examine a problem, our understanding of it adapts.  In this way we must reevaluate both the problem and the solution.  Continuous planning allows for this dynamic where a plan alone constrains learning.

Scrum’s Sprint, as I’ve said before, provides a balance between space for creative problem solving and focused decision making.  The outcome of a sprint allows us to reevaluate our understanding of the problem space and whether we are taking the product and organization in the appropriate direction.  Here we see how we can utilize the Scrum framework to embody the Agile value of Responding to change over following a plan.

tl;dr

There is a lot of misinformation out there that comes with a strong movement like Agile. It’s been coopted by some, but the vast majority see these opportunities as a way to make sure the 8 hours they spend away from their families is spent wisely. That’s where I fit in.

With that in mind, I believe very much that Scrum, like many things, can be used for both good and bad.  When used well, it provides a safe zone for sustainable, creative teamwork.  When used poorly, it sucks as bad if not worse than waterfall/ad-hoc.

I don’t teach Scrum such that teams go back and simply use it to manage work.  Many don’t get beyond that, but in my courses, webinars, and conversations we talk about the human factors, theory, and sustainable practices that make Scrum work.  This is the legacy I want Deming, Scrum, Agility, and others to be remembered by.  Not velocity and commitment.

Visual Studio 2012 is a great step forward all by lonesome.  The in-the-box enhancements below have been great as our teams and I adopted Visual Studio 2012: 

• Visual Studio 2010 SP1 Project compatibility
• Extensible Test Explorer with Continuous Testing
• Asynchronous Solution Loading
• File Preview tab a-la Sublime
• Quick Launch
• Code Clone – Code Duplication Detection
• Seriously enhanced Diff tool

Great stuff, but there are some Extensions that I just can’t live without.  Here are some of my favorites:

Chutzpah Test Adapter

Test your javascript along side C# and other code using Jasmine or QUnit with the new Test Explorer.  Continuously test your javascript and, now, coffeescript!  Find out how here.  Mathew Manela is a stud.  Thank him for this one.

xUnit Test Adapter

Run xUnit tests alongside other test frameworks without feeling the need to go ‘all-in’ on any one framework.

Specflow

Specflow allows you to create and run BDD style tests right inside Visual Studio.  If you’d like a demonstration of how we use Specflow to enable fast feedback and frequent releases, contact me for a lunch and learn.

Web Essentials 

This extension is so chock full of goodness I couldn’t begin to list the features.  If you’re doing any kind web dev in Visual Studio, you need this extension. It adds coffeescript, LESS, Handlebars, and Mustache support.  Allows you to embedded resources, IE hacks, and vendor specific prefixes.  Stop wasting your time and just get it.

Gister

Shameless plug for my extension that allows you to publish code snippets to http://gist.github.com.  This goes along with PsGist which lets you do the same from Powershell.

VsVim

You might scoff at this one, but I’m a giant fan of VsVim.  Learning Vim exponentially improved my productivity and I’ve been able to integrate that into my Visual Studio use thanks to Jared Parsons.  You rock man!  Thanks.

The weekend prior to Agile 2012, Scrum.org hosted a face-to-face gathering of trainers.  These are a mandatory part of being a Scrum.org trainer and it’s a great time.  These are bright and passionate people that really want to make the world of software development better. 

This year as part of the face-to-face meetings, trainers are being asked to present a lightning talk on a topic they are passionate about.  There was everything from Organizational Amnesia (great!) and a Tasty Cupcakes game from Don McGreal.  In all, I think it was the best part of the gathering.

My Talk

For my part, I presented on my experiences this year building what I’ve been calling Feature Focused Apps.  My plan is to continue expanding this talk and the posts that go with it throughout the year.  I’ll be taking it on the road to user groups and CodeMash in January.

I’d love your thoughts on the topic and what you’d like to understand more.  I’ve been negligent in my posts on the topic, but in due time…

With diffgist there’s a nice –launch option that opens the gist in your default browser.  I tend to send them to the clipboard via | clip, but this is really convenient.  I think I’ll add this to gist also.

Here’s the command help:

NAME
New-DiffGist

SYNOPSIS
Publishes Github Gists of current git diff.

SYNTAX
New-DiffGist [[-Name] <String>] [-Description <String>] [-Username <String>] [-Public] [-Launch] [<CommonParameters>]

DESCRIPTION
Publishes files as Owned or Anonymous Github Gists.

PARAMETERS
-Name <String>
The name to use for the filename of the Gist (minus .diff)

-Description <String>
(optional) The Description of this Gist.

-Username <String>
The Github username which will own this Gist.

-Public [<SwitchParameter>]

-Launch [<SwitchParameter>]
When specified, the default browser will launch to the created Gist URI

————————– EXAMPLE 1 ————————–

C:\PS>diffgist -Description “Hello.js greets all visitors”

Publishing a private Gist

————————– EXAMPLE 2 ————————–

C:\PS>diffgist -Name “Hello” -Description “Hello.js greets all visitors” -Public

Publishing a public Gist

Refactoring done earlier didn’t execute acceptance tests. This makes me wonder why we even have acceptance tests. The acceptance tests (and the bug they surfaced) are fixed. Ugh. Professionalism people. Please.

I say somewhat facetiously, because I actually copied it out of my almost submitted commit command. I was really close to sending it and that would have probably been the end of it.  It’s unlikely anyone would have noticed it, especially the person I was directing this passive aggressive comment towards.

Follow My Own Advice

I’ve blogged recently about recognizing signals (here and here).  Obviously, I’m not following my own advice.  I need to go and find out why this person doesn’t care about the acceptance tests and either convince them they are important or find a better way.

Uncomfortable Part

Rather than be passive aggressive in silence, I need to have the discussion.  It’s not going to be comfortable, but I have something we can both agree on: we both want this to be successful.  If we can keep the conversation focused on the success of this project, we can find an understanding.  If I use the same tone in our conversation that I’m using in this commit message, well, it’s not going to go well.

Fortunately, I wear big boy pants (when I go to the office) and I’m willing to get over a little uneasiness for the sake of my creation.  Do it a few times and it gets much easier.

Simple Solution

It turns out this was able to exist in our codebase for a few days, because we aren’t running our acceptance tests as part of the build. I plan to remedy that tomorrow.

Unfortunately, the room was filled with crickets during the meeting.  The one person who should have understood the technical details, was puzzled.

“They’re All Idiots”

Often our natural first reaction is to be frustrated and angry that no one “get’s it.”  I mean, this is the right way!  Just look closer.

Unfortunately, this doesn’t help anyone or anything.  It simply puts you in a defensive posture at a time when you need to be offensive.

A COMMUNITY OF SPECIALISTS

Crickets are a form of feedback.  The first signal in this conversation was “the last few months.”  That’s too long a feedback loop for anything.  It’s telling you that your message is not appropriate for the audience.

We are a community of specialists.  The crux of actually accomplishing things as a team is communicating successfully across specialties.  This is why analogies are so helpful and common.

ASIDE: We strive to be generalizing-specialists, but we have specialized skills. It’s something that has made the human race successful. Get over it.

THEY’re Telling You Something Stupid

When people choose to attend your meeting, it mean’s they are interested.  If they leave confused or less interested, the problem isn’t with the audience.  The message needs work.  It needs to resonate with the audience and their context.

Here are some things you can do:

Understand Your Audience

Ask around and learn about those who have an influence in the outcome of your presentation.  Understand their knowledge and perspective.  What does success look like for them.  For big points in your topic, ask yourself what might be confusing to this person or that.

Fail Fast 

A “few months” is way to long a feedback loop.  Check in with someone that represents your audience every so often and share your thoughts.  This will help you to learn what works and what doesn’t.  Don’t use the same person too often.  They’ll be building on previous discussions unlike your end audience.

Stay Calm

Don’t get frustrated or defensive during the presentation.  When you see the deer in headlights, start asking questions of the audience.  Find out where the gap is.  After having talked through the content with earlier helpers, you should have more than one way to explain things.