Passing along some information from Mike Kelly regarding the 2009 schedule for the Indianapolis Workshops on Software Testing (IWST.) It’s pretty short and dense, so I’ll just copy from here:

We’ve posted the 2009 schedule for the Indianapolis Workshops on Software Testing. We’re looking for people willing to share experience reports and people who just have a general interest in the various topics and would like to attend and ask questions.

Here’s a summary of the lineup:

• February 26, 2009: Presenting test results

• March 27, 2009: Test-driven development

• June 27, 2009: Test design and development

• August 28, 2009: Testing mobile devices

• September 26, 2009: Automation and performance logging

• October 29, 2009: Time management for testers

• November 21, 2009: Managing your focus while doing exploratory testing

If you’re interested in attending any of the workshops, please drop me a line at mike@michaeldkelly.com.

I sent him an email saying that I would be interested in the March and October sessions. Perhaps you have some interest in the same/other sessions?

Software development analogies are sometimes fun and potentially revealing. With that being said, I wanted to throw out a small nugget I thought of.

Growing up, I watched a fair amount of sitcoms until I realized the basic plot device. Essentially, something happens where a character on the show makes a choice, is worried about the ramifications of that choice, and is then somehow deceptive. They keep having larger and larger miscommunications and problems as the show goes on, and more problems (and hence hilarity), ensue due to keeping the problems under wraps. Eventually the characters realize the mistake, and the show ends with everyone having learned a valuable lesson.

• Note: I am not affiliated with any of the sitcoms mentioned below, nor do they support me financially. :)

Full House

At some point, I got pissed because I just thought “Why doesn’t Stephanie just tell Danny Tanner that she wrecked the car instead of trying to hide it for like two more days? I’m pretty sure Danny’s going to flip out and kick Comet and ground you, but at least you get it out in the open. There’s definitely nothing to be gained from hiding it. Why would any rational person do this?”

Anyway, this process happens all the time on sitcoms. But the question that I thought of was: does it happen on software projects?

I suppose that part of this is a human tendency to attempt to delay pain whenever possible. You take a known undesirable and put it out into the future where it may or may not happen. Seems like a good thing, right? Maybe I can fix up the car with my piggy bank and Uncle Jessie’s spare tools, or maybe dad won’t notice the car being missing. Maybe I won’t be working on the project anymore. Maybe we can add a couple of people, that seemed to work for another project that was having similar problems. And maybe we can make it up. Maybe we can pull a few late nights or work some Saturdays to get this project back on track, or maybe we can just cut some corners here and there and fix them later when we have more time.

Unfortunately, by delaying communication, you lose a chance to align expectations early. There is a mental shift cost incurred when a stakeholder doesn’t quite know what is going on. The earlier that you can provide this information, the more time the person involved gets to stew on the information and try to come up with alternate satisfactory solutions or at least understand what is going on. In this sense, having transparency is key. No one likes to come to the end of a project that they thought was going well but see that things have gone amiss.

Unfortunately, in the real software world, hilarity rarely ensues from not communicating the true status of a project. More often money is lost and quality suffers due to a compressed schedule based on unrealistic expectations. People don’t get grounded, they get “let go”.

Home Improvement

Tim “The Toolman” Taylor always took a break around the twenty-minute mark of the show Home Improvement to talk to his neighbor Wilson across the fence about the problems he was facing during that episode. Tim would explain the situation, and Wilson would give him some sage advice that made a lot of sense to Tim. Tim would go back into the house armed with his somewhat rudimentary version of the wisdom that Wilson imparted, and things would get patched up.

It seems like Tim would have benefited from doing retrospectives before the twenty-minute mark (or, as sometimes happens in the software world, after the show, or maybe in the break room.) Maybe looking at the process and decisions made at five minute intervals throughout the episode would have helped to get at the root of the problem before it got worse. By the time that he got to the twenty minute mark, there was like one commercial break and five minutes of show left to resolve the underlying problems that were plaguing his family. They could have taken a kaizen approach to their family relations to lessen the chances that 2/3 of the way through the show the communication process was producing unsatisfactory results. I wonder how Tim’s experience with power tools and the search for ever more powerful tools mirrors some developers’ tendencies.

What this post hopefully stresses is communication of project status and expectations and evaluation of the development process. Do you have a sitcom example of your own?

A majority of open source projects have a paucity of documentation. However, they still have value as a working system. I argue that improving the documentation of a codebase intended for general use is one of the highest value activities that a developer can do. Although documentation may not be directly contributing to the codebase, the writer provides a valuable service by understanding the code and imparting that knowledge to others.

I would go so far as to say that there should be open source technical writers. They look for interesting projects to write basic documentation for. While there are a smattering of tutorials for certain frameworks, they are not condensed, are not authoritative, and are often misleading because of changes to the framework or convoluted examples. When the core developers move at the speed of the forum or even IRC, it’s tough for a new person to have anywhere near that amount of knowledge. A centralized wiki with pertinent and up-to-date examples is quite useful.

If you are not yet a badass developer, this kind of project aids you in three ways. First, you gain experience looking at unfamiliar code bases and reasoning about them. This is especially helpful if you maintain code, and also assists you in writing more maintainable code. Second, you get some street cred for being closely involved with the developers on the project and working with them. You’re likely to learn something from the alpha geeks and advance your skills. Third, your writing skills improve, which helps you out in many areas over the long run.

In a nutshell, the kind of people who are building their own system or framework are generally not obsessed with documenting for average people. This could be due to time constraints or general personality traits. But the value that they create is wasted if people are not comfortable interacting with it.

Clojure

There is an interesting thread on the Clojure discussion group about making examples readable and general ways to help developers who are new to the language and want to code idiomatically. One post mentioned the Clojure page on concurrency. If you can read through the example code there and want to tackle concurrency (which is supposed to be a strength of Clojure), then I applaud you. This isn’t a knock against Clojure, it’s just so new that most everyone who’s interested has been playing around with it and trying to understand it better.

One of the most important points in the post is that to get a community rallied around a language or framework, it’s necessary to have good documentation so people aren’t put off by it. The Clojure folks are getting there, as there are a couple of wikis around that people dump stuff into.

qooxdoo

The qooxdoo framework illustrates one of my favorite examples of excellent open source documentation. When I first started looking at it, I was impressed by the amount of examples, pictures, screenshots that were included. The manual is rife with examples and code snippets.

They have a huge demo area that shows how simple effects can be created using at it. Looking at these demos, I started visualizing about how exciting it would be to work with this framework. As another great demo, it has an API documentation viewer, which itself is written with qooxdoo. It must have taken time to generate all of this…

Parting thoughts

On the other hand, one could argue that with a nascent open-source product, having too many people involved early is problematic for direction and quality density. Also, the people who create code which uses the product will constantly have to change their code because the underlying architecture or best practices change. It’s the bleeding part of the bleeding edge.

I’m not saying that I’m committing to doing any of this… :) Just thought that this was an interesting line of thinking.

I think I just formalized why I like reading.

A six month project expects approximately

6 months * 4 weeks / month * 40 hours / week = 960 hours.

If you read material pertaining to your project that takes five hours at the beginning of your project, you only need to save 12.5 minutes per week to justify reading it. That’s maybe two or three google searches for trivial topics or a pretty in-depth search if you’re not sure what you’re looking for. I think that the time invested pays for itself pretty quickly.

But what’s more, you learn solutions that are even better than the ones that you might have come up with otherwise because your learning is condensed and you are seeing best practices and rationale.

Title: How to Win Friends and Influence People Authors: Dale Carnegie Published: 1990 Length: 304 pages

Of the books that I have read recently, this one seemed to be a contentious one. I discussed this book with a friend who is in sales, and we came to completely different conclusions on the book’s premise. His idea was that the book contained a bunch of ways to manipulate people to get what you want, whereas I felt like the book provided methods to better understand, empathize, and work with people.

Throughout, Carnegie displays quite a bit of humor and wit, and gives memorable anecdotes to drive the points he makes home. Some things are trite on the outside, but they are quite useful once internalized. Here are some of the major points.

Carnegie starts out by talking about why he wrote this book. He had been searching for “a practical, working handbook on human relations,” but could not find anything. So he looked through history and tried to figure out how influential people in the past worked with the people in their lives, and wrote this book. Carnegie talks about research done that showed that “even in such technical lines as engineering, about 15 percent of one’s financial success is due to one’s technical knowledge and about 85 percent is due to skill in human engineering – to personality and the ability to lead people.” I thought this was interesting, and personally agreed.

The most important theme that Carnegie emphasizes is that no one thinks that they are wrong. Everyone, even a criminal, acts rationally based on his or her world model. Hence, criticizing people or arguing with them will only serve to harden their resolve and make them less likely to want to be around you. Seek to understand and empathize, and you can see where they are coming from.

The only way to get someone to change their ways or do something you want them to do is to have them want to do it. Giving honest and sincere appreciation and being “hearty in your praise and lavish in your approbation” are two great ways to show someone that you do like what they are doing. However, people have a great skill in seeing through baloney, so the praise you give must truly come from the heart.

Carnegie asserts that you must never complain. No one likes a complainer. He states that there is no better way to ruin a marriage than to constantly nag your partner. I can’t speak from experience, but that seems correct.

Avoid arguments and telling people they are wrong. If you must, do it constructively and explain how you have made the same mistake in the past and that it should be easy to correct. Good people aren’t going to mess things up on purpose. Sometimes it’s just a misunderstanding, and you should be quick to point out when you are or were wrong. If you are to point out shortcomings, call attention to people’s mistakes indirectly and in a private venue.

When someone has complaints, let them vent until they have nothing left to vent about. Show them that you care about their concerns and let them know what you are going to change to fix those concerns.

My friend in sales was somewhat right. There is importance in being able to sell, and this book can help do it well. Although you may not be in sales in the conventional sense, every day you are selling your ideas and opinions. Those who have good ideas and present them well are more respected, those that can’t fall by the wayside. You want to win people over to your ideas, and this book gives concrete ways of doing this.