Tuesday, March 30, 2010

Warming up Sites Before Running Selenium Tests with NUnit’s SetUpFixture

I’ve been running in to a number of problems where my Selenium tests are timing out when they first run in our automated build environment. Our Selenium test build runs three times a day and sets up the environment from scratch using a distribution package created in another automated build process. [Note: This meets my goal of always testing what you release, not just what you can build.]

The issue with starting from scratch every time is that ASP.NET has to compile the site the first time a Selenium instance spins up. This takes long enough that several tests can fail due to timeouts. My local repave process (hacked together from several PowerShell scripts) hits the site before launching my tests; however, I needed some way to do this within my test process.

NUnit’s SetUpFixture attribute to the rescue!

This handy attribute lets you mark a class to run a one-time setup or teardown for a namespace or for an entire assembly. If you qualify the class with a namespace, then setup/teardown will run once for that namespace only. If you don’t qualify the class with a namespace it will run once for the entire assembly it resides in.

This is awesome.

Using this approach, I can fire up a WebClient instance and hit URLs which will force compilation of the target sites. Here’s how I do it:

using System;
using System.Net;
using NUnit.Framework;
using Telligent.Evolution.Tests.Selenium.Common;


[SetUpFixture]
public class AssemblySetupFixture
{
    [SetUp]
    public void WarmUpSiteAndControlPanelBeforeTesting()
    {
        try
        {
            var webClient = new WebClient();
            webClient.Proxy = null;
            var requestUrl = http://MyHost/SomeUrl;
            var result = webClient.DownloadString(requestUrl);
            requestUrl += "/ADeeperUrl/";
            result = webClient.DownloadString(requestUrl);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }
}

Note there’s no namespace declared, so this snippet runs once for the assembly it runs in. Yes, the catch block is ugly, but this is my first pass at this and I’ll figure out something smarter to do with Exceptions later.

There are a number of ways I could have skinned this cat, but frankly I’d been wanting to try out this NUnit feature for some time and this gave me a nail to use that hammer on. (Because you can’t get enough bad metaphors in one sentence…)

Thursday, March 18, 2010

Selenium Exception: Unable to Delete File (parent.lock)

Problem: When using FireFox for Selenium tests, Selenium RC is throwing exceptions with the error message “Selenium.SeleniumException: Failed to start new browser session: Unable to delete file” with a reference to a “parent.lock” file in your temp folder. Cleaning up FireFox profiles doesn’t help.

Solution: You may be using an older version of the selenium-server.jar. Go grab the latest download of Selenium RC. At least that’s what fixed it for us…

Friday, March 12, 2010

Getting an Assembly From the GAC

Windows Explorer lets you browse the Global Assembly Cache (GAC) and drop strongly-named assemblies in if you’ve the proper permissions. What you can’t do is pull things out of the GAC using Explorer. Explorer hides some abstractions of the GAC from you, preventing you from pulling assemblies out.

I had the need to validate that an assembly in the GAC was indeed the version I expected; however, once a file’s in the GAC you can’t just drag it out using Explorer. (I couldn’t rely on the Version number shown in Explorer – it’s a DLL related to some SharePoint work and the pain of dealing with versioned assemblies in SharePoint is a rant I’ll save you from. Today.)

You can get around this with a quick bit of command-line fu, though. Actually, it’s just copy, so it’s not even fu.

Using an admin account, open a command prompt and change to the %SYSTEMROOT%\assembly folder. There are a number of folders under here:

C:\Windows\assembly>dir /b
GAC
GAC_32
GAC_64
GAC_MSIL
NativeImages_v2.0.50727_32
NativeImages_v2.0.50727_64
temp
tmp

Use dir /s to find the assembly you’re looking for. (Line breaks inserted)

C:\Windows\assembly>dir TelligentEvolution.Wss.Global.dll /s /b
C:\Windows\assembly\GAC_MSIL\TelligentEvolution.Wss.Global
       \4.1.31029.3047__454c7a96e9526647\TelligentEvolution.Wss.Global.dll

Now you’ve got the full path to the assembly. Use copy to get it where you want it.

C:\Windows\assembly>copy GAC_MSIL\TelligentEvolution.Wss.Global
   \4.1.31029.3047__454c7a96e9526647\TelligentEvolution.Wss.Global.dll 
   d:\temp
        1 file(s) copied.

Poof. Now I can get at the file with Reflector for a bit of inspection.

Friday, February 12, 2010

Software Engineering 101 in Nashville on 2/27

Jon Kruger, Leon Gersing, and I are repeating our highly successful SWE 101 event (event wrap up blogged here) in Nashville, TN, on 2/27. Registration’s already open, so please join us if you’re in the area.

Oh, wait! You can actually attend via a Live Webcast if you’re not in the area! Register for that here.

The event’s schedule’s on the registration pages, but it will follow the same format as the one in Columbus: the morning focuses on laying out fundamentals, and the afternoon is all hands-on test driven development putting the morning’s content to practical use.

Come prepared to learn, interact, pair up, and cut some code with other geeks. It’s how we roll.

Thursday, February 11, 2010

Case Studies on Benefits of TDD

I’m a believer in test driven development. For many reasons. I don’t do it enough myself, the people I’m around don’t do it enough, the people I talk to don’t do it enough. For many reasons.

One commonly cited reason is a lack of evidence about TDD’s benefits. I’ve always found that a bogus argument, because I think it’s fairly easy to look to specific metrics around code complexity and bugs in a before/after environment.

Without further ado, here are some links pointing to various studies on TDD. Note these links are to TDD. I didn’t even go down the route of “show me stuff that backs up the benefits of unit testing, not just TDD.”

Using Bing I Googled this search phrase: “test driven development studies” and got these great hits:

From Biblio, an entire page of studies.

In InfoQ, an article on a study from folks at Microsoft and IBM. The InfoQ article links to the Empirical Software Engineering Journal’s article which costs $34 to read. Evil, greedy, profit-grubbing Microsoft hosts the article here for free. A comment in the InfoQ article points out some great contrarian questions which you need to ask yourself about TDD.

There’s also a video on Channel 9 interviewing one of the study’s authors. (I haven’t watched it. Yet.)

An interesting paper summarizing several other studies in industrial, semi-industrial, and academic environments. Benefits in the latter two environments were not as apparent, particularly in the academic. I wonder if some the low benefit in the academic environment is due to a lack of real-world experience both in the students and their instructors.

Does Test Driven Development Really Improve Software Design Quality an awesome article published in IEEE Software back in March/April 2008. Read closely the sections on misconceptions and cons. Chase down some of the other referenced reading there, too.

Hopefully you’ll find these articles and links a good starting point for your own reading. Use them wisely when trying to make the case for selling TDD (or even just unit testing, period) to your teams, management, and customers. Keep in mind these critical points:

  • Be honest. Unit testing and TDD aren’t silver bullets. Crap code driven by crap tests driven by crap requirements is still a pile of crap.
  • Be honest. Your perceived productivity will drop. You’ll be knocking out less features on any given iteration/cycle/release.
  • Be honest. You’ll suffer additional productivity losses as you learn how to do testing, preferably in TDD fashion.
  • Be honest. There will be culture and skills issues with your team, your management, your customer, and you.
  • Be honest. Testing and TDD is often more about long-term gains than short term. You’re trading feature velocity for overall quality and maintainability.
  • Be positive. The gains you’ll realize from moving to TDD are significant: reliability, quality, maintainability.
  • Be positive. The speed at which you’ll realize those gains will greatly improve as you move forward and get up over the learning curve.
  • Be positive. There’s a growing mountain of solid study-based evidence around the benefits of unit testing, particularly TDD. I emphasized “evidence” because too often we geeks get so fired up about things that we are passionate about that we ignore arguments based on facts and evidence.
  • Be positive. There are specific metrics you can use to show the gains: complexity metrics (NDepend, FTW!), code coverage, decreasing bug counts, fewer escaped-to-customer bugs, increased velocity around future maintenance and expansion.

Now go forth and do battle! “Sancho, my armor!”

Friday, January 22, 2010

Making DevExpress & ReSharper Play Nicely

I use both DevExpress’s IDETools and JetBrains ReSharper on my dev boxes. Why? Because I’m a tool whore. That and I like different pieces of both of them. DevExpress gives me awesome visualization, and R# gives me awesome other stuff.

Here’s my quick steps to making them play nicely together in VS 2008:

  1. Install DevExpress tools first
  2. Install ReSharper
  3. Start VS, fill out license info as you’re prompted
  4. Tell ReSharper to use R#/IntelliJ key mappings
  5. Disable DevExpress options I don’t like
    1. DevExpress | Options
    2. Set Level to Expert (lower left corner of dialog)
    3. Editor | Auto Complete | Intellassist | Setup | clear Enabled checkbox (I like R# completion better)
    4. Editor | Auto Complete | Intellassist |Parens & Brackets | clear both options for Smart Parens and Smart Brackets (I’ve always had grief with these conflicting, so I shut ‘em off)
    5. Editor | Clipboard | Smart Cut(Copy) | clear Enabled (Plain ol’ VS copy/cut/paste works for me)
    6. IDE | Shortcuts | search for Ctrl-B (PasteReplaceWord) | clear Enabled (I use Ctrl-B in R# to go to definition)
    7. IDE | Shortcuts | search for Ctrl-Alt-F (QuickFileNav modal) | clear Enabled (I use this shortcut in R# for formatting code. R# gives me Crtl-N and Ctrl-Shift-N for type/file nav)
  6. Force ReSharper once more to use its shortcuts. ReSharper | Options | General | Visual Studio Integration | Restore ReSharper keyboard shortcuts | ReSharper 2.0 or IntelliJ IDEA | Apply

These are MY preferences, but it’s what works for me.

Thursday, January 21, 2010

Flag Parameters are Evil! (Or at least unclear)

The more parameters you have in a method call, the more chances you have to screw things up. Moreover, method signatures with boolean parameters (flags) add in clarity problems, too – even if the input parameter is well-named.

Instead of exposing a non-private method with a flag, make that method private and instead expose two well-named, explicit methods which are simple facades over the newly private method.

Instead of

protected T CreateRestServiceInstance<T>(bool impersonateEnabled)

use

protected T CreateRestServiceInstanceAsServiceUser<T>()
{
   return CreateRestServiceInstance<T>(false);
}

protected T CreateRestServiceInstanceWithImpersonation<T>()
{
   return CreateRestServiceInstance<T>(true);
}

private T CreateRestServiceInstance<T>(bool impersonateEnabled) 
{
  //wonderful shiny stuff here
}

You’re making your class’s API explicit and clear, and you’re cutting the risk of someone goofing up and missing something important – like invoking a REST endpoint as a service account instead of impersonating the user.

Not that I’ve ever done this myself, mind you…

Saturday, January 16, 2010

I Am Not CodeMash

Every year I get lots of people thanking me for putting on CodeMash. I get comments about how the conference has changed their thinking and gotten them fired up to go do great things back at work. I’m humbled and flattered, but I’m not the force behind the conference. I’m not CodeMash.

Brian Prince puts in 300 – 400 hours a year handling registration and overseeing our web efforts. Brian is CodeMash.

Jason Follas puts in around 200 hours dealing with sponsors, t-shirts, schedules, and hundreds of other little tasks I never hear about but somehow magically get done. Jason Follas is CodeMash.

Jason Gilmore puts in nearly 200 hours overseeing the 500 session submissions we get for 60-some-odd session slots, plus he handles all the schedule planning and timeslotting, and he handles all the speaker coordination. Jason Gilmore is CodeMash.

Our content selection committee of Dianne Marsh, Joe O’Brien, Jay Wren, Sarah Dutkiewicz, and David Stanek had the tremendously difficult task of culling through those 500+ submissions to pick out the best possible lineup for the conference. CodeMash has lots of Great Stuff to do, but it’s all based on the amazing content. Dianne, Joe, Jay, Sarah, and David are CodeMash.

Darrell Hawley and Mike Woelmer took on tremendous responsibilities for owning the coordination for the Enter The Haggis concert and all our VIP travel coordination, respectively. If you think that’s an easy task please go kick yourself in the teeth. Moreover, they did that at a point when I was in an awful spot with work and life and could not have handled either task at all. Darrell and Mike are CodeMash.

Our 58 speakers and 3 keynoters delivered the amazing presentations that make CodeMash really shine above many other conferences, regardless of size. Those folks are CodeMash.

Scott Zischerk, Chris Woodruff, Mike Wood, and Steve Andrews are always pitching in to lend a hand wherever it’s needed, regardless of whether it’s schlepping trash, handing out tshirts, or manning the registration booth. Scott, Chris, Mike, and Steve are all CodeMash.

Finally, look at the attendees who show up and get outside their comfort zone. Look at those attendees talking in open spaces during the conference and interacting with folks they’d never get a chance to otherwise. Look at the folks pairing up in the Coding Dojo and polishing up their skills. Look at the folks in Leon Gersing’s PreCompiler TDD Workshop session who filled out retrospective cards with blurbs like “Loved a practical workshop with Agile!” or “Never paired before, but learned a lot!” or “Didn’t know anything about Rails before today, but loved the experience.” Those folks are CodeMash.

I’m not CodeMash. YOU are CodeMash. I’m just lucky to be a part of it. Thanks!

Now go do something with what you learned. Me? I’m taking a nap.

UPDATED: I completely forgot to mention Jeff Blankenburg, who spends a lot of time and creative energy doing up our amazing logos, badges, and banners. Jeff Blankenburg is CodeMash!

Wednesday, December 16, 2009

Favorites of 2009 (Telligent-Style)

Jana started an interesting thread on a Telligent-internal mailing list, which prompted Josh to follow up with a great blog post. The topic was four questions:

    1. What was your favorite work-related or field related or technical read for 2009 (white paper, book, etc)

    2. What was your favorite new Telligent feature for 2009?

    3. What was your favorite enhancement for Telligent products in 2009?

    4. Favorite external app/product/feature you used in 2009?

I enjoyed a bit of a retrospective over the year and came up with the following responses.

Favorite work- or field-related or technical read: Leading Lean Software Development by Tom & Mary Poppendieck. Awesome motivator for what organizations can do if they get the entire group solidly behind transforming how they build, deliver, and support/service products and services. Bob Martin’s Clean Code would be a close second, Stand Back and Deliver a solid third.

Favorite Telligent feature for 2009: I was lucky enough to work with a great group of guys (Dave, Nate, Sean) on v2 of Telligent’s web services API. They kicked ass with amazing work and evolved our web services into a solid, powerful approach for extending and writing new apps on our Telligent Evolution platform.

Favorite enhancement for Telligent products in 2009: If you’ve read my blog or Tweets much then you know I’m a Lean fanatic. My favorite enhancements for our products in 2009 are those we didn’t. Nope, that’s not a typo. Our leadership gave us some great support for rethinking how we approached development in the last four to six months. As a result, we focused hard on a lot of things behind the scenes. Features were dropped from the backlog. Features were simplified in our current codebase. Features were CUT from our codebase. As a result, we’ve ended up with an improved codebase and significantly simplified user experience. Cutting and simplifying is an absolutely glorious feeling. Lean, FTW!

Favorite external app/product/feature of 2009: Visual Studio, because while I’m not a “real” developer, writing code is a great way for me to stay engaged with things I’m very passionate about. (Testing, development practices, beautiful code.)

Friday, November 27, 2009

Book Review: Beautiful Testing

Beautiful Testing: Leading Professionals Reveal How They Improve Software, by Adam Goucher and Tim Reilly. Pub by O’Reilly, ISBN 0596159811.

This is a great book for testers, leads, and managers to read to get a better picture of where your testing process can bring value to your work. A few sections of this book didn’t get me much value, but the vast majority of the book left me frantically scratching notes and folding corners of pages over. I read the book over a weekend and came away with a large number of major additions to my QA roadmap I use at work.

Kamran Khan’s chapter on fuzz testing reinforced my ideas that choking your system with invalid parameters and input data is a tremendous way to shore up that system’s stability. I also really enjoyed Lisa Crispin’s and Alan Page’s separate chapters, both of which emphasized value-driven, sensible approaches to test automation.

If you want an amazing story around how testing can directly impact the lives of those around you, read Karen Johnson’s chapter “Software in Use.” Johnson ties a visit to an Intensive Care Unit to work she’d done on equipment in that ICU – it’s rare anyone sees that practical a link to work we do in this industry.

Other highly worthwhile chapters include the piece on Python’s development process, the overview on TDD, Mozilla’s regression testing philosophy, and others. The Python chapter, in particular, is a tremendous testament to how a rigorous testing philosophy can guarantee very solid releases even with a broad, distributed team of varying skills.

As my examples above point out, there’s a great amount of broad-stroke value in the book; however, a wealth of smaller, critical points abound in various chapters as well. Some weren’t phrased exactly like this, but I’ve taken away these other concept as well:

  • Track the source of your bugs (test plans, exploratory, developer, etc.) and pay special attention to bugs found by customers. These “escapees” point to areas to shore up in your test plan.
  • Mindmaps are a great way to brainstorm out your test plan or test areas.
  • Use small tools like fuzzers to help create your baseline input data.
  • 100% passing rates for your automated tests isn’t reasonable. Investigating 100% of your failing tests to determine whether the specific failure matters is reasonable. (I already firmly believed this, but it was nice to see in print!)
  • Using image comparison to check formatting.

This is one of the better books I’ve read this year, and it’s absolutely worth adding to your shelf.

Several Book Reviews

97 Things Every Project Manager Should Know by Barbee Davis. Published by O’Reilly. ISBN 0596804164.

This is a terrific collection of small articles on many aspects of project management and successful team leadership. There are a large number of authors involved in this work, so the articles’ voices vary, but each one is very well written and clear.

I loved Neal Ford’s and James Graham’s articles on productivity and finding good individuals, and William Mills’ Meetings Don’t Write Code certainly fit right in with my core philosophy.

The book’s very easy to read and has a lot of valuable insight. Highly recommended!


Elements of Programming by Alexander Stepanov and Paul McJones. Pub by Addison Wesley. ISBN 032163537X.

Serious approaches to algorithms for the hardcore computer science geek. Heavy on math, low on applicability for me and my line of work – but I’m sure lots of folks will find it very useful. Lots of concise, in-depth discussion of foundational knowledge, and plenty of exercises to help evolve your skills.

The tone’s exceedingly dry and academic, and I got very tired of the authors repeated assertions that you need to be using a “real programming language such as C++.” Guess all the value-providing projects I’ve helped roll out in Perl, Java, C#, and other languages haven’t counted.

That said, this is a wonderful book for those interested in raising their skills in hardcore algorithms.


The CSS Anthology, 3rd ed by Rachel Andrew. Pub by Sitepoint, ISBN 0980576806

It’s Sitepoint, it’s CSS, it’s pure goodness in full color. Another amazing book from Sitepoint that is clear, concise, example-driven, and highly useful. I love how many of the topics are written in a before/after or progressive style. It’s a great mix between a cookbook and tutorial approach.

There’s enough content here to make this book useful to CSS novices or advanced folks.


The Manga Guide to Calculus, Hiroyuki Kojima, et. al. Pub by No Starch Press, ISBN 1593271948.

The Manga Guide to Molecular Biology, by Takemura Masaharu, et. al Pub by No Starch Press, ISBN 1593272022.

Both these books follow the same great approach as the Manga Guide to Physics I reviewed some time ago: Break a complex idea down in to small pieces, clearly explain it with practical examples, and use the fun Manga comic style to wrap the entire concept in a great story.

I never took calculus in high school or college, yet I was able to get through the Guide and come out at the end with a pretty fair understanding of it. Moreover, I actually enjoyed the learning journey!

My nine year-old daughter loves these books and always reads through them after I’m done. She’s not coming away from the books with great knowledge of the concepts, but she’s finding them interesting, fun, and is less intimidated with the subjects. I think that’s a big win because these guides are laying some good ground work for her to come back to later.

Friday, November 20, 2009

Displaying the Document Properties Toolbar in Office Documents

The Document Property bar in Office 2007 is handy, particularly if you’re working with SharePoint document libraries and have added some custom columns. Those show up as nifty properties in your document, like so:

Unfortunately, if you close the property bar it’s not very intuitive on how to get it open again. Use Office | Prepare | Document Properties to get it back. Yeah, that Properties command is under “Prepare.” UI Fail, but there you have it.

(Posted because I continually forget how to get the properties bar back.)

Monday, November 16, 2009

Automate Activation/Deactivation of SharePoint Features

Click, wait, click, click, wait, click, wait, wait, click, wait, … Life as someone working with SharePoint development when you’re trying to update features you’re working on or testing. It sucks.

Here’s a little Watir on Ruby script to ease your pain. You can launch this from the command line with a “-a” or “-d” arg to activate or deactivate. Edit the @siteroot and @*Features variables to match your needs.

This uses some XPath-fu to find the Activate or Deactivate button for the feature named in the two *Features variables.

No, it’s not pretty. Yes, there are <x> different more betterer ways it could be done. It skinned the cat I needed skinned and I’m happy.

UPDATED: Refactored it a bit.

require 'watir'
require 'optparse'

@siteroot = "http://w2k3rs/"
@collectionFeatures = [ "Telligent Enterprise Menu Items",
            "Telligent Enterprise WebParts"]
@siteFeatures = ["SharePoint Integration for Telligent Enterprise",
            "Telligent Enterprise Search Replacement for WSS v3" ]

$options = {}

opts = OptionParser.new 
opts.banner = "Usage: SpiFeatures [$options]"
    
$options[:activate] = false
opts.on( "-a", "--activate", "Activate SharePoint Integration" ) do
    $options[:activate] = true
end
$options[:deactivate] = false
opts.on( "-d", "--deactivate", "Deactivate SharePoint Integration" ) do
    $options[:deactivate] = true
end
opts.parse(ARGV)    
   

$action = "Activate" if $options[:activate]
$action = "Deactivate" if $options[:deactivate]

$browser = Watir::Browser.start @siteroot + "/_layouts/ManageFeatures.aspx?Scope=Site"
$browser.speed = :fast

def toggle_feature(feature)
    $browser.button(:xpath, 
        "//table[@class='ms-propertysheet']//table//table//tr[td[h3[contains(.,'" + 
        feature +
        "')]]]/../../../..//input[@value='" + 
        $action + "']").click
    if $options[:deactivate] then 
        $browser.link(:text, "Deactivate this feature").click 
    end
end

@collectionFeatures.each do |@feature|
    toggle_feature(@feature)
end

$browser.goto(@siteroot + "/_layouts/ManageFeatures.aspx")

@siteFeatures.each do |@feature|
    toggle_feature(@feature)
end

$browser.close

Monday, November 02, 2009

CodeMash 2010 Registration Open!

Registration for CodeMash 2010 is open!

Of course I’m biased, but I think the sessions we’ve got this year are better than ever, and the list of PreCompiler sessions is simply insane.

Keynoters for this year’s conference are Mary Poppendieck, Hank Janssen, and one more amazing guy we’ll be announcing shortly.

Early bird pricing is $175, good through 30 November after which it jumps to $220. The PreCompiler is $75. The Kalahari is offering its usual amazing value prices of $88 for a “Hut” room. This means you can stay three nights, hit the PreCompiler and the full conference, all for less than $600. I don’t think you can find any better value for a conference; certainly not any national level conference!

Go to CodeMash. Just do it.

Wednesday, October 28, 2009

Another Free Event: MS Dogfood II Conference

The good folks at Microsoft’s Columbus office are putting on the second annual Dogfood conference. It’s a FREE two-day event loaded with content on Silverlight, WPF, SharePoint, SQL Server, Exchange, Azure, F#, Windows 7, and loads of other neat stuff.

The conference runs 12-13 November at Microsoft’s Columbus office.

Check out the conference’s agenda and register! (Note that you have to register for both days separately!)

Friday, October 16, 2009

CodeMash Sessions are Live!

If you’re not following CodeMash on Twitter, you may have missed the announcement that the session list for CodeMash 2010 is up.

The selection committee received 450 submissions this year and had an insanely hard time working through them. All 450 were terrific submissions. The committee came up with an awesome lineup!

Registration for CodeMash will open up shortly, and it will go quickly, so be ready to jump and get in line!

Monday, October 05, 2009

Writing a Good Session Abstract

If you’ve got a great idea for a conference session, you absolutely have to spend time getting your abstract right before you submit it. Your abstracts really need to pitch to two separate audiences: the selection committee and the attendees themselves. Work hard to explain the value folks will get from your session.

Here are some thoughts based on my experience writing a few abstracts.

  • Align your content with the event. Is your session even a good fit for the event you’re submitting it to? I’ve only submitted to one national conference, and I had to really twist around my submissions to make them seemingly fit with the conference. They didn’t. I didn’t get selected. One of the organizers (a good pal) specifically called out the lack of fit as the reason other organizers weren’t interested.
  • Avoid overly broad sessions. “Introduction to .NET 3.5” or “Testing is Great!” might be interesting, but generally speaking they’re way too broad to get much value out of in a 60 or 75 minute session. Focus down on some specific items. Instead of a broad testing talk, narrow it to some tools, like Selenium, or mock or unit test frameworks. Speak to something specific in those.
  • Titles matter. Really. Cool titles like “I am MOSS Tester! And You Can Too!” sound nifty, but they’re often going to lose the selection committees and attendees. Sure, make your title catchy, but make sure it showcases what your session’s about.
  • Explain what attendees will get out of the session. Make it clear what your attendees will learn during your session. “You’ll leave this session with a handle on ways to smooth out your project’s environment” or “This session will show you a great system for boosting customer collaboration and increasing your code’s quality” are good examples.
  • Give examples of what’s discussed. Let attendees know what you’ll be talking about. “This highly interactive session will show you three specific tips: improve your estimation, use a daily standup to keep a close focus on your progress, and work in retrospectives.“ This helps the selection committee understand if the content fits in, and it helps potential attendees see they should be skipping that bogus session on Drag and Drop Driven Development to attend your presentation.
  • Show some prior feedback on the session. Have you given this talk before? If so, try and collect some feedback on the presentation. Twitter’s given me some awesome blurbage I reference in my abstracts. “’I think I've learned more about Fitnesse from Jim than anyone else. :-)  It was a great talk -- standing room only.’ Michael Eaton, http://is.gd/2ounG” Items like that, particularly ones you can hit via live URLs, give you immense credibility.
  • Write a concise abstract. The one paragraph of your abstract is like the one spoon tasters get at a chili competition. This is hard to do. You need to work really hard on making the one paragraph highly impactful. Fall right back to your elementary school fundamentals: introduction, body, conclusion. Set a hook with a great opening: “Bugs. Crashes. Malfunctions. Complete meltdowns. We run into difficulties in our work each and every day.” Follow that on with the value propositions to attendees and examples of what’s covered. Finish up with a great closer that will make your attendees’ mouths water, figuratively, at least.
  • Write a coherent abstract. I’ve been on a number of content selection committees, and I see most CodeMash submissions even though I’m not on its selection committee. I’m always amazed at the handful of unreadable, muddled, flat out awful submissions we get. Spend time to make sure your submission is clear. Don’t bother submitting if you won’t take this step. Tough love, but it’s true: incoherent submissions are nearly always immediately dropped from consideration.
  • Edit, re-edit, then get it reviewed. Write the draft, step away from it, come back and edit it later. Several times. Get the abstract out to your colleagues and friends for their feedback. Iterate through this several times.

Your speaker bio is every bit as important as your abstract, particularly if you’re not well-known by the content selection committee. Writing a great bio is a topic for another post, likely by someone else because I’m contrarian and non-conformist with my bios. Just do me one favor: make sure your bio isn’t longer than your submission…

Here’s an example of one of my abstracts. Feel free to borrow, copy, or outright steal it and adapt it as you need.

Title: Leadership 101

Abstract: It doesn’t matter what point you’re at in your career, you need to understand some fundamentals about good leadership. If you’re well into your career you need to know how to get the most out of your teams. If you’re just starting then you need to learn what good leadership looks like – and how to help ensure you’re getting the leadership you and your colleagues need to succeed. In this session you’ll learn basic concepts about respect, responsibility, communication, and teamwork, based on experience drawn from Jim’s years of serving in the military, playing competitive sports, and working in a wide range of jobs.

Feedback:

I knew Jim Holmes was a good speaker, but holy crap. That's a great way to start a day.” Joe O’Brien, http://is.gd/2ovna

“Jim Holmes is a fantastic speaker... Audience is completely engaged in his Leadership 101 talk at #erubycon” Raju Gandhi, http://is.gd/2ovxN

Tuesday, September 29, 2009

Running an Event on the Cheap

I’ve been a part of teams organizing a pretty good number of developer community events here in the Heartland over the last few years. I’ve helped with medium-sized Code Camps / Days of .NET hosting 150 - 200 people across four tracks and I’ve helped with much larger events like CodeMash, where 550 people attend seven tracks plus open spaces.

While those events are really rewarding, they take a significant amount of time and effort to put on. You generally need several people working as a tight team to pull these off. You need a big venue, you need audio visual support, you need food, and you need significant sponsor support to pay for all that. Many times you’re hostage to your venue’s catering services, which means you’ll be paying high costs for mediocre (at best!) food. (Thank God for the Kalahari, where the venue’s food is actually really good.)

Twice in the last year I’ve been part of great events which were a snap to put on: the .NET University last November and the Software Engineering 101 last week. Both these events filled the room (90+ people) and were a great success. Where CodeMash generally has well over $100,000 go through the cash register, metaphorically speaking, both .NET U and SWE101 were put on for less than $500 each.

Here are a few concepts you can use if you’re interested in putting on an event without the tremendous work of a larger event.

  • Leverage your community. First and foremost, you need great contacts in your community to pull these off. Build those contacts, because you’ll be looking to them to help with content, venues, marketing, and finding sponsors.
  • Have a clear vision on the event’s goals. Keep a very narrow focus on what you want to present. One track. Period. Think hard about the audience you’re targeting. We specifically targeted .NET U to folks who were not involved in the community. We blogged and spoke to user groups: “This event isn’t for you – but tell your colleague that’s never been to a community event.”
  • Content is King. Hand pick great speakers to deliver topics lining up with your event’s goals. Make sure they’re on board with the vision and clearly understand what you want them to deliver. Getting their suggestions on what to deliver is fine, but make sure they first understand what the event is trying to do. Remember, one track. You’ll only need four to six speakers.
  • Get a clear schedule early on. Get your schedule nailed down before you press forward. Times, presenters, descriptive titles, short and clear abstracts.
  • Find a free venue. You absolutely can’t do one of these events if you have to pay for a venue. Look to your local Microsoft office, look to community colleges, check with your local business community, check with local training companies. Drive home the idea you’re putting on a free event to improve the skills of your local developer community.
  • Find free AV resources. You need one projector and one screen. If it’s a larger venue you may need two projectors and two screens synched together. Check with community members to see if they have gear they can borrow from their companies. Check with your MS reps. Check with local training companies.
  • Avoid venue catering costs. Many venues with catering services look to make their money not on renting the facility, but by charging you $14 per head for an awful box lunch. Instead…
  • Bring in food and drinks. Line up bagels and coffee from Panera or some place similar. Panera delivers, so that was a big win for me. I paid $300-ish for coffee and bagels for 100 folks. I ran to Target and picked up another $150 of sodas, water, and snacks. (Funyons, FTW!)
  • Skip lunch. Look to a venue with several restaurant/fast food choices near by, then clearly indicate to your audience that they’re on their own for lunch. Leave one hour in your schedule to support folks getting out and back. Attendees of a free event won’t mind running out to get their own food as long as you make it clear from the start.
  • Find a couple sponsors. Reach out to companies that are already involved in your community. You need $500 to support an event for 100 geeks. It’s simple to make a pitch asking for $250 from two companies. Don’t let sponsors come and take over your event, but make sure they get some exposure via logos on slides and frequent mentions during the event.
  • Skip recording. Recording sessions sucks, plain and simple. It’s a hassle, there’s a lot of moving parts, you need special gear, it interferes with presenters, it never turns out as well as you’d hoped, it… The list goes on and on. We’ve tried for years to get recording working at various events, and it’s always been a complete PITA for one reason or another. Skip it.  (Note: If someone with a history of success volunteers to do this, then by all means take them up on it. Just don’t let the recording come anywhere near injecting friction into your speakers’ gigs, or the audience’s ability to get great content.)
  • Find a registration system. Look to something like Microsoft’s community registration system, Microsoft Group Events. Look to Meetup.com. Look to something similar. DO NOT WRITE YOUR OWN SYSTEM.
  • Pimp the event. Get your schedule up on blogs. Get the word out to your own community contacts. If you’re in the .NET world, make sure your Microsoft Developer Evangelists help you spread the word. Reach out to your local business and educational communities. Hit up local media.
  • Expect drop off. Free weekend events have drop off rates of up to 40%. Free weekday events often see over 20% drop off. Accept it. It’s not you. Well, maybe you do need different deodorant.

This list isn’t all that long, is it? It’s all common sense. You can do a great event on the cheap. You can have a whole lot of folks learn some great content and come away all excited and motivated to improve their environments. You can do this without giving yourself an ulcer and losing sleep. Honest.

Go do a neat event. Get people fired up.

Then do more.

Thursday, September 24, 2009

Software Engineering 101 Conference Wrap Up

Wow. 90 or so folks showed up yesterday for an amazing event: the Software Engineering 101 Conference. Everyone seemed pretty fired up, energetic, and happy at the end of the day after hearing Leon, Scott, and Jon cover some great topics.

We went through Object Oriented Programming basics, SOLID software design, code metrics, and production debugging. All these were fundamentals[1] for an afternoon of test driven development in a hands-on workshop environment. Leon, Scott, and Jon delivered some great content and really got the attendees engaged before proceeding into the afternoon workshop.

The afternoon workshop was really, REALLY fun to observe. There was a tremendous amount of energy going on in the room as folks paired to solve the problem given them: part of the rules engine for Greed from the Ruby Koans.

One interesting thing really struck me: how quickly all the attendees jumped in together and got productive in pairs. Pair programming freaks a lot of people out for a number of reasons, so it’s sometimes hard (at least in my corners of the .NET world) to sell.  We never even gave the attendees a choice. We told them in several pre-conference mails that the afternoon would be pairing. Leon fired off the workshop with “Get ready to pair.” Not once did we open the door for folks to work by themselves, and I think it really paid off.

We’re looking at some possibilities for repeating this conference, perhaps even as an online/live session. More news on that if anything comes of it.

This was an awesome day for me, and I’m really thankful that Leon, Scott, and Jon jumped on board when I pinged them. I couldn’t have gotten three better presenters in the Heartland, and that’s sayin’ something because the Heartland kicks every other region’s assets for speakers.

One last thing: many thanks to EdgeCase and Cardinal Solutions for jumping in with sponsorship funds. We were able to get food, drinks, and snacks for the attendees, all courtesy of Joe and Jeff. Many thanks also to Microsoft and Brian Prince for opening up the venue to us.

[1] I had someone remark that Scott’s Production Debugging presentation wasn’t on the same content line as the OOP, SOLID, metrics, and TDD sessions. They were right. BUT! I pulled in Scott because A) his session has a tremendous amount of fundamental material in it, B) He’s an awesome presenter, and C) I wanted to see it and I got to pick the conference’s content. :)

Tuesday, September 22, 2009

Leading from the Front

In my Leadership 101 talk I really harp on the importance of leading from the front, particularly as you get higher up in an organization. I illustrate this with a story of the battle of the Somme in France in World War I. The allied generals were so far from the front they didn’t know about flooding which made it impossible to cross the battlefield in any effective manner. Tens of thousands of casualties resulted in the first day of what turned in to a long campaign. All because the generals lead from the rear, where the environment was completely different.

I just don’t understand “leaders” of an organization who don’t take the time to learn the details of the environment their organizations operate in. How can you lead if you don’t know your environment, your clients, your company, or your people?

The Dayton Daily news had a great article in its Sunday paper on executives and upper level management at Miami Valley Hospital here in Dayton who are terrifically engaged and at the front. Leaders there do four hours of “rounds” a week at the hospital – as doctors do rounds to visit their patients, executives and management do rounds to visit their workers. They also interact with their customers – the hospital’s patients.

This is a terrific practice that keeps the hospital’s leadership in touch with the pulse of their workers and the hospital’s patients. The article, plus its two companions here and here, highlight the great benefits the entire hospital is seeing because of these policies.

Making this sort of effort ensures leaders understand the environment their people are working in. Leading from the front ensures leaders understand the environment the company creates for its customers. Leading from the front ensures leaders are keeping open lines of communication to workers and customers, and are seeing things about their company first hand.

It doesn’t matter if you’re leading a huge company of 70,000, a small company of 150, or a team of three. You’re jeopardizing your success if you’re not consistently and frequently getting out to interact with clients and workers.

Lead from the front. The benefits are amazing.

Subscribe (RSS)

The Leadership Journey