Fixing “The Group Policy Client Service failed the logon”

We’ve had a rough few days with some virtualized servers on our testing infrastructure. Some SAN issues required some repair installs on a couple VMs, then we had a couple corrupted partitions on those VMs.

I’d fixed all those issues up, but ran in to problems trying to RDP directly in to the systems. I’d get errors “the Group Policy Client Service failed the logon” after entering my credentials.

Turns out the user profile on the server was corrupted. I didn’t have much in there, so I simply deleted it (System, Advanced Properties, User Profiles). This deleted the corrupted profile and I was able to get on the system successfully.

Book Review: 97 Things Every Programmer Should Know

97 Things Every Programmer Should Know, edited by Kevin Henney, pub by O’Reilly, ISBN 0596809484.

This is another great book in O’Reilly’s “97 Things Every <fill in the blank> Should Know” series, and it’s every bit as good as the others. The book follows the same highly successful format of creating a book full of two-page articles taken from submissions to a public wiki. Each article is concise, highly pertinent to our profession, and well-written.

The articles are grouped in broad categories such as Bugs and Fixes, Design Principles and Coding Techniques, Refactoring, and Tests/Testing/Testers. There’s a couple great sections on softer skills such as learning/continuing education and customer interaction. I was really impressed that the testing section was so long with such great content in it.

Nearly every article in the book was highly useful to me, but a couple highlights would have to include:

• Bob Martin’s The Boy Scout Rule on leaving code better than you found it
• Steve Smith’s Don’t Repeat Yourself on keeping duplication out of your design and code
• Jon Jagger’s Do Lots of Deliberate Practice on how to improve your skills
• Paul Homer’s Simplicity Comes from Reduction on the power of deleting code

This book’s nicely balanced between highly technical concepts (avoiding Singleton patterns, code metrics) and more general topics (education, scheduling). It’s a great addition to your bookshelf.

Kalamazoo X is This Weekend!

Last year I got to attend an amazing conference: The Kalamazoo X Conference. Mike Eaton put on an amazing conference with a terrific lineup and a fantastic format: 20 minute talks from great folks like Mike Wood, Brian Prince, Leon Gersing, and others. (I’m leaving off all the other great speakers because of time and space. Don’t take it personally if you were one.)

KalX’s content isn’t about in-depth technical geekery, it’s about communication, process, design, and figuring out how to improve and motivate yourself.

KalX is back this year, and it’s this weekend. You NEED to go to this conference. It’s like a combination of CodeMash and TED all mashed up in one day of glorious, awesometastic content.

Shake out your schedule. Get there. It’s the region’s second best conference after CodeMash, and I don’t say that lightly.

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…)

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…

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.

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.

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!”

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.

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…

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!

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.)

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.

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.)

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

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.

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!)

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!

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