My Learning Elixir (erlang) Setup

The last Dayton Clean Coders meeting spiked my squirrel sense as Chris McCord and Matt Sears of our awesome host Little Lines talked about their excitement for Elixir. Of course, I’ve hung my several dozen half baked projects up for the moment as I scratch that itch.

Elixir is a Ruby inspired language that compiles down to Erlang bitcode. You can fall back to any Erlang library and many of the syntaxes, but the language is crazy easy to pick up if you’ve tried any of the other Ruby inspired languages like Coffeescript.

Here’s my setup for walking through the Elixir Getting Started:

  1. vim with my vim-config
  2. iex, interactive elixir will load compiled elixir modules found in the same directory. This means I can put bigger functions, modules, protocols, etc. into *.ex files and then explore and play with them using iex.  You need to run

    to reload after compiles.

  3. Guard running this Guardfile for automatically compiling the *.ex files.
vim + iex + guard = flatting the curve

vim + iex + guard = flatting the curve

Moving Blob Storage Between Azure Subscriptions

We recently had some delays getting some Azure accounts coordinated for a client and chose to use a team subscription instead.  After some work, the delays were resolved and we had the client managed subscription in place.

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:


Release Cadence: You’re Not Agile If You’re Not Shipping

I’ve spent the last 3 years exploring the in’s and out’s of different Agile frameworks and methodologies.  I’ve worked with large commercial firms, government contractors, and small ISVs to adopt one set of Agile practices or another.

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.

logo-verticalThis 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.

Creating an Offline Web Platform Installer for Service Bus 1.0

One of my clients is evaluating a number of Service Bus tools.  One of those includes the Azure Service Bus which is now available for on-premise deployment.

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:


Adaptive Problems Require Responding to Change Over Following a Plan

Feedback was recently posed on the community forums regarding the Webster-ish definition provided for Scrum by Ken and Jeff.  If you don’t recall from the Scrum Guide, the Scrum Overview definition reads:

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.