May 2004 - Posts

Visual Studio 6 SP6 is Now Available

Go get it. Fix list is located here.

Yes thats right, I still program in VB6. It pays the bills sometimes.


Update 5/21/09: Changed the download link.

Posted by Wayne Allen | 5 comment(s)
Filed under:

Practical Testing

Len Holgate is writing a series of posts on Unit Testing with a non-trivial example. Good stuff, check it out.
Posted by Wayne Allen | with no comments
Filed under: ,

Precision & Accuracy

This came across this on the IXP list today from Don Wells and I thought it was one of the better descriptions of precision and accuracy.

One thing we all need to remember when talking about metrics is the difference between accuracy and precision.

Consider a yardstick that I take and cut a foot off of.  I then repaint it and put the markings back on.  So I have a yardstick that is only 2 feet long instead of 3 feet.  This yardstick is not accurate but it is precise. That is, I can measure something twice and get the same measurement.  I can
measure two things add the measurements together and expect the sum to equal a single measurement of the two things stuck side by side.  I can add these measurements because they have precision, unfortunately all the measurements are wrong because they are not accurate.

Now let's take a thick piece of elastic slightly less than 3 feet long and mark it like a yardstick.  To measure we stretch it out just a little bit and measure.  This yardstick has accuracy but not precision.  That is, when I measure something it is real close to the correct number but every time I
measure it is slightly different.  It has low precision.  If I add measurements together the precision gets even worse.

Most of the measurements we make as software people have accuracy but not precision just like the elastic yardstick only worse.  This is because we deal with people and subjective numbers.  The point of all this is that many of these numbers don't work well in complex formulas.  That is, you can not add, subtract, multiply or divide these numbers.  It is often better to find a first order measurement with good accuracy and reasonable precision instead of doing lots of math on numbers with little precision.

Posted by Wayne Allen | 1 comment(s)
Filed under:

Agile Customer Mailing Lists

Via Brian Marick:

Jim Shore has started the fit-users mailing list.

"This list is for general discussion of Fit. Appropriate topics include how to use Fit on your project, fixtures, and approaches to test-driven development using Fit. Direct discussion of Fit development to fit-devl@lists.sourceforge.net."

<https://lists.sourceforge.net/lists/listinfo/fit-users>

Also via Brian Marick:

Agile customer mailing list

Inspired by a couple of consulting trips, I've started a new mailing list: Agile-Customer-Today. Here's the blurb:

This group is to serve those people whose role on an agile team is to guide the project. They're called, variously, "customers", "product owners", "business experts", "Goal Donors", etc. It's a really hard job, so this group is for those people to ask questions, share ideas, and describe their experiences.

A typical conversational thread might start with one customer saying, "I am having real trouble explaining my stories clearly enough that they're really 'done' when the programmers think they're finished. For example, [...]. What do other people do?" Then other people on other projects will share tricks of the trade.

This group isn't only for customers. Having worked with customers on past projects, programmers, testers, and managers can help other customers today. But this is not a group *about* customers; it's a group *for* them. The acid test for posting should be: "Will my words, read today, help some customer on some project do her job better?"

You can sign up by sending mail to agile-customer-today-subscribe@yahoogroups.com or visiting: http://groups.yahoo.com/group/agile-customer-today.

Posted by Wayne Allen | with no comments
Filed under:

How Agile got Agile

This came through on the Agile Project Management group today from Mike Beedle of Scrum fame. A nice summary of how we got the “agile“ moniker and a few things to think about.

> Actually, "Agility" (and especially "Business Agility")
> pre-dates XP, etc.

Yes, it does.  In fact, the word "agile", as in "agile development"
was chosen because it was thought to be a good "sales" word among
upper management -- something managers could understand and
associate with it as something cool but without any
connotations of failure.

If you recall, there was a "Business Agility" wave circa (95-97),
that "never failed".. perhaps because the Internet wave took over,
or perhaps because its lack of overall specificity.  Either
way, "Agile" was a cool word with management and not associated
with failure, "being passe", high risk, or high expenses,
like BPR, TQM, Knowledge Management, Future Creating Company,
or Learning Organization.

When we were at Snowbird in 2001, we proposed many words:
  adaptable, lightweight, lean, adaptive, essential,
  people-oriented, value-oriented, (and many more I can't recall),

I proposed that "agile": word for the above reasons. 
(Of course, the rest of the group voted for it.)

In my opinion, some things "were lost" from the meeting.
Here are some things that still remain to be fully explored:

Values
------
- Trust
- Respect
- Sharing Knowledge
- Constant Learning
- People over Process
- Communication
- Feedback
- Simplicity
- Courage
- Truth of the code/Executable
   using the code to learn

Principles
----------
Customer Value
Individual Capability
Collaboration
Adaptation
Simplicity
Customer connected to process
Integrated Testing
Short Cycles
Lots of feedback
Social Networks
Feedback outside of the team
Always ready to ship
Deliberate Diversity
Minimal Roles
Minimal Artifacts
Low Bureaucracy
X functional teams

Posted by Wayne Allen | with no comments
Filed under:

Explorable Languages

Bret Pettichord of Lessons Learned in Software Testing fame is doing his Scripting for Testers class in the Northwest this week for PNSQC. He and I got together last night to shoot the breeze and had some great conversations. If you are looking for someone on the cutting edge of agile testing you can do no better than Bret.

One that really stands out for me was out discussion on “explorable” languages such as Python or Ruby. Explorable languages essentially have an interactive mode that let you play with the system you are building without the edit, save, compile, run sequence. You just type stuff and the computer responds. From a testers perspective I can really see the advantage of this mode of interaction, plus you get a record of what you did.

As I am asked to take over code written by someone else I find myself wanting the same kind of thing as I start writing unit tests. I just need to play around with the system for a while so I can see how the original author was thinking. It made me realize how the next generation of developer tools could help with this understanding by providing more than just a list of classes/methods/attributes, but indicate somehow how they interact.

Posted by Wayne Allen | 1 comment(s)
Filed under:

Portland XP

If you are in Portland, OR tomorrow come join Ian Goodrich and myself as we compare and contrast XP projects we coached.

See XPDX.org for more info.

Posted by Wayne Allen | with no comments
Filed under:
More Posts