A couple of months ago I was asked to facilitate a discussion for a local church’s council members. After nearly 12 years of work, they had come to the point where it was time to close their doors from an emotional, personal and financial perspective. As you can imagine, a church has a strong emotional bond for its members – especially those who spent many years of their life building it up. Over the course of several hours we were able to move the council through an objective look at their current state while honoring the necessary subjective and emotional content they felt the need to express. By the end, with the group literally in tears, they had all agreed on a course of action.

When dealing with these kinds of emotional situations as a facilitator, there are some steps you can do to help make things go smoother:

1. Take Control – This is key no matter what you are facilitating, but especially true in high-emotion situations. You need to be able to focus and direct conversations. In this session, both the existing pastor and the council president initially stayed standing with me in the front of the room. I “allowed” it – until they couldn’t control their need to jump into the conversation and answer questions, at which point I asked them both to sit down
2. Understand the situation – I’ve had some experience with building churches, and with the challenges this particular group faced. This isn’t about being an expert, but instead about being able to empathize and predict where the conversation is going
3. Understand the grief process – When a facilitation involves end scenarios – closing of a business, shutting down of a team, talking about death – you should be prepared for working through a grieving process. While the grieving process is talked about to be in stages – denial, anger, bargaining, depression and acceptance – it can be much more complicated. In this scenario it meant that I had to be prepared for the group to outright reject the discoveries they were making – and then to be angry with them, then to bargain through them until we got to acceptance. Amazingly, I saw very clear delineations throughout the session:
1. Denial – This stage is interesting in that emotional reactions can lead people to reject outright facts in front of them. One key to getting through denial is gently keeping the information in front of them. The picture above is from the facilitation session – the yellow stickies were all of the group-identified challenges, compared to the greens which were the positives they had. This helped keep the group reminded that we weren’t meeting because they thought there was a problem – there was a problem.
2. Anger – Once the true facts of their situation came to light, there was a lot of anger. This was generally expressed in the form of blame – blame towards each other, towards the church body, towards other groups that were involved. The key here is to allow the expression of anger without allowing it to devolve into personal attacks. One particular challenge was that people who were still in the denial phase felt they needed to “defend against the attacks”.
3. Bargaining – As the group began to accept where they were, the bargaining started in. “Maybe we can just make it through Christmas.” “We could sell X, Y and Z, and have each of us contribute $10,000.” While this kind of exploration is healthy – and perhaps vital at an earlier stage – it’s important to recognize that the group needs to move through this, and as a facilitator keeping back to the facts the group developed will help this.
4. Stay Calm – When emotions are running high, anything is bound to happen. I’ve had people walk out of emotional retrospectives, yell and scream, and seen physical outbursts. One of your most important jobs is to maintain a safe environment. This does not mean shutting down all outbursts, since different groups may have different cultural norms. Instead, carefully watch the other participants to see if they are pulling back, and ask others to hold their expressions – or to leave, if necessary.
5. Allow the group to decide – As a third-party not caught up in the emotional aspect you may feel the need to point details out, or get the group to a vote, thinking that will help. The best outcomes I see are when the group feels it is time to decide. You may be able to help this with timeboxed activities, where you can give gentle reminders of where they should be at, but ultimately the group has to feel they came to the decision through their discussions. With this group, I timeboxed the exploratory exercises into short segments, and had an overall timebox for the session that we agreed on which helped keep the group focused during the more open time periods. While I was fairly stringent on the shorter timeboxes, I was willing to allow the general conversation to go a little longer if needed. At the end, the group decided to do a vote to close – and unanimously voted to do just that.

Dealing with any kind of reflective activity can generate strong emotional responses. It’s up to you as the facilitator to not only guide the group – but to stay out of the emotional whirlwind. By doing that, you can help the group discover the decisions they need to make and allow them the room they need to work through those decisions.

Update: The presentation was recorded, and is available here: https://www311.livemeeting.com/cc/mvp/view?id=M3KWN7. No meeting key is required.


var list = new List { "fish", "and", "chips" };
for (int i = 0; i < list.Count; i++)
{
  list.Add(list[i].ToUpper());
}


As the title points out, this will cause an infinite loop, and will eat up all of your memory. What happens is that we iterate through the list once (i=0; list.Count = 3) and then add an element to the list. So the next loop we have (i=1; list.Count = 4). This is because anything in the parenthesis of the for operator will be evaluated every loop.

There are three options:

1. Don't modify the list you are working on
2. Save off list.Count to a variable and use that variable in the loop
3. Use generics and/or Linq instead of manually walking the list yourself.

And the code was a dummy example code, nothing in use in any real system.

• On February 2nd I’ll be presenting to the Ft. Lauderdale .NET User’s Group on Data Dude (also known as Visual Studio Team Edition for Database Professionals). We’ll be covering how to do Test-First Development of your data and schemas. Information and Registration
• On February 11th, I’ll be presenting Debugging Production .NET Applications to the Pasco County .NET User’s Group. This will cover the basics of memory management, CLR and using WinDBG and SOS to uncover what is *really* going on with your application. More information and registration
• Then, on February 15th-17th I’m doing a class entitled Essential Skills for the Agile Developer (.NET Edition) in Tampa. This is a hands-on class covering mocking, TDD, Design Patterns and many other aspects to help you produce faster, higher-quality software
• Finally, I’ll be speaking at the South Florida Code Camp on February 27th down in Ft. Lauderdale

Hope to see you at one or more of the events!

Go Vote Now!

It was a pleasure serving the community that I got to work with, and hope you all have a Happy New Year!

The Koans are especially interesting because all you really need to do is setup a working environment and go. It tells you what you need to do next, by way of running the tests and seeing what passes.

I thought to myself, why the heck don’t we have something like that for other languages? There are some obvious challenges – for example, doing it in .NET it has to be compiled, and some of the things don’t map well. But in the spirit of, “If you’re going to fail, fail as publicly as possible” I’m announcing the launch of the DotNet Koans.

The goal of the project is to eventually have a guide for C#, F#, and VB.NET – likely in that order. Ok, likely the first two, and hopefully some VB’r will jump on the third. Right now I have three of the twenty-five koans ported over – AboutAsserts, AboutNil and AboutArrays. I’ve hacked together a custom runner for xUnit.NET which tells you where you are every time you build.

My goal right now is to get everything ported over pretty much as-is, and then look at making sure this fits a good progression. For example, I don’t know if the Koans will lend themselves to LINQ, but that’s something that should be covered.

The project is now public up on GitHub at http://github.com/CoryFoy/DotNetKoans – feel free to download it, play with it, and contribute (or critique) if you’d like.

In this intensive, hands-on, 3-day session we cover the basics you need to know to get a better understanding of working in an agile environment. We include topics such as Planning and Estimating, Test-Driven Development, Refactoring, and working with tools such as Visual Studio Team Edition, NUnit and Resharper. This ensures that by the end of the third day you’ll have a solid footing for working in an agile environment.

The course is taught by Cory Foy, a former Microsoft Field Engineer who is active in both the Agile and .NET Communities. Cory has helped organizations of all sizes adopt agile practices, and has been an invited speaker to events such as TechReady and the North America Software Craftsmanship conference. In addition, he’s contributed to projects such as NUnit and FitNesse, and helps run the Agile Tampa user’s group when he isn’t speaking at other user groups.

Course dates are February 15th-17th in sunny Tampa, FL. Registration is $1295 and limited to 15 people. Breakfast and lunch will be provided all three days, and group and company discounts are available. To get more information, or to register, please contact info@coryfoy.com or call (813) 352-0233, or see the registration site.

We look forward to seeing you there!