Ballot Debris

Thoughts on Agile Management, Leadership and Software Engineering

Software Safety Myths

clock October 23, 2011 08:56 by author Chad Albrecht

In some research I’m doing for a new course, I ran into Nancy Leveson’s list of myths regarding software safety.  She presented this list in her 1995 book Safeware: System Safety and Computers.  The list of myths are as follows:

  1. The cost of computers is lower than that of analog or electromechanical devices.
  2. Software is easy to change.
  3. Computers provide greater reliability than the devices they replace.
  4. Increasing software reliability will increase safety.
  5. Testing software and formal verification of software can remove all the errors.
  6. Reusing software increases safety.
  7. Computer reduce risk over mechanical systems.

 

We will do well to remember this list as we design complex software based systems.

 



Branching and Merging–Proceed with Caution!

clock February 25, 2011 08:59 by author Chad Albrecht

Over the last few years I have worked with teams that feel a need to using Branching as part of their “best practices” tool set. The ALM Rangers were even nice enough to show teams how to build a mature branching scenario in their Visual Studio Team Foundation Server Branching Guide 2010.  PROCEED WITH CAUTION!  There is a large overhead in using branching and merging.  The branching part is easy, it’s the merging part that will kill you.  Done infrequently, the merge process can be a huge undertaking in many cases taking days to complete.  Here is a quote from the original VS 2005 Branching and Merging Primer:

A branching and merging strategy involves a tradeoff between risk and productivity. You trade the safety of working in isolation for the increased productivity of working with other people. The productivity increases come with a cost—the additional effort required for merging software assets sometime in the future.

Often, there is no need to adopt branching as the teams are small enough or using shelves will suffice.  If you feel you need to branch, do so for the right reasons.  What are the “right reasons?”  In a nutshell, you absolutely NEED to isolate some code from other teams/repositories.  Examples might include:

  • Development on a new feature is continuing while the current version is releasing.  (branch by feature)
  • Teams are practicing design by contract and only want the final contract to be used by other teams. (branch by team)

What are some branching and merging anti-patterns to watch for? Here are few (thanks Chris Birmele):

  • Merge Paranoia—avoiding merging at all cost, usually because of a fear of the consequences.
  • Merge Mania—spending too much time merging software assets instead of developing them.
  • Big Bang Merge—deferring branch merging to the end of the development effort and attempting to merge all branches simultaneously.
  • Never-Ending Merge—continuous merging activity because there is always more to merge.
  • Wrong-Way Merge—merging a software asset version with an earlier version.
  • Branch Mania—creating many branches for no apparent reason.
  • Cascading Branches—branching but never merging back to the main line.
  • Mysterious Branches—branching for no apparent reason.
  • Temporary Branches—branching for changing reasons, so the branch becomes a permanent temporary workspace.
  • Volatile Branches—branching with unstable software assets shared by other branches or merged into another branch.
    Note   Branches are volatile most of the time while they exist as independent branches. That is the point of having them. The difference is that you should not share or merge branches while they are in an unstable state.
  • Development Freeze—stopping all development activities while branching, merging, and building new base lines.
  • Berlin Wall—using branches to divide the development team members, instead of dividing the work they are performing.

Remember, think long and hard about jumping into branching and merging.

Some additional reading:

Fowler on Feature Branching

Fowler on Continuous Integration



Pex and Moles - Isolation and White box Unit Testing for .NET

clock January 28, 2011 08:21 by author Chad Albrecht

Microsoft Research has a great tool for automatic unit test generation (Pex) and delegate method replacement (Moles).  These tools can be a great way to get unit testing up and running on your brownfield project.

http://research.microsoft.com/en-us/projects/pex/



Agile Bugs & Risk

clock December 16, 2010 04:46 by author Chad Albrecht

I think we are all well aware that bugs cost more money to fix the longer they live.  What are the reasons for this?  As some of you have heard me discuss in various presentations, a lot of it has to do with context.  As developers move on to new areas of code, they loose context for previous areas that may contain bugs.  Specifically, they loose the fine details on how that area of the code works, thus preventing a quick fix of the bug.  I’ve done some analysis of some of the teams I’ve worked with and have found the time to fix a bug varies with time as shown in Figure 1.

 

image

Figure 1

 

This curve shows us that bugs caught early can be fixed fairly quickly.  However, after a certain point, there is a spike in the amount of time it takes to understand to the code and fix the bug.  I have seen this spike occur somewhere between one and three months, depending on the developer.  Obviously this in and of itself is reason to fix bugs early.  But there is another monster waiting for us in the closet…bugs love to procreate.  (just like in nature)  The longer a bug lives in code, the more chances developers have to write code to accommodate the bug, thus creating another bug or two or three.  Left unchecked, this growth becomes exponential.  (Figure 2) I’m guessing this is no surprise to many of you.

image

Figure 2

 

We can look at both Figure 1 and Figure 2 as “cost curves.”  By this I mean that at points low on the curve we incur low cost and at points high on the curve we incur high costs.

In Agile, we seek to change the way teams test software.    We want to eliminate the “let me finish it all, then you can test” mentality with “let’s write a little and test a little.”  This behavior encourages teams to find bugs quickly, before they get into the wild.  Lisa Crispin and Janet Gregory thing of this as “Coding and Testing Progressing Together” in their book Agile Testing.  What is the point of cranking out a bunch of code if it’s riddled with bugs?

There are a ton of advantages to using Agile iterations.  One of which is improved quality.  By driving towards zero bugs every iteration, we can keep all of our costs on the bottom of the “costs curves.”  This is one way that Agile helps limit the risk of ballooning costs late in a project.



Corporate Greyhound Racing

clock September 4, 2010 04:26 by author Chad Albrecht

Betting on a greyhound race can be tons of fun.  You find a cool sounding greyhound, check the stats, then lay down $20 to win. (or some other bet variation)  We are ecstatic when our greyhound wins, collecting our money and touting the prowess of our keen eye for the stats.  When we lose, we attribute it to the dog having a bad day, the weather, the law of averages, etc.  If we are an avid better, we may begin to use complex formulas that take into account the dog’s past performances, current weather conditions, time of day, etc.  In fact, my wife’s uncle has written a book on such formulas for greyhound racing.  Even after an exhaustive amount of work we are still left with a game of chance each time we place a bet.  As hard as we try, predicting the future is hard, improving our chances takes significant effort and in the end we may be left with nothing more than a 1 in 10 chance of being right.  We’ll come back to this in a second…

Let me now turn the focus to that of software project estimation.  I’ve been spending time lately reviewing all the COCOMO II (B. Boehm et al.) material along with concepts of variable covariance. (as I talked about in this blog post)  What I am realizing is that formulas used by COCOMO II bare significant similarities to those used in gambling, e.g. greyhound racing.  We look at the empirical data (if we have it) from the team’s past projects and try to determine (guess) certain characteristics for our new project.  For example, in COCOMO II’s early design model, Person Months(PM) is estimated using the following formula:

PM = A x Size^B x M

Where A is a local coefficient that depends on things like organizational practices and type of software.  Similarly, B is an exponent that reflects the increased size of the project based on its novelty with Size being measured in thousands of lines of source code.  Finally M is another multiplier based on seven project specific attributes defined as follows:

M = PERS x RCPX x RUSE x PDIF x PREX x FCIL x SCED

I’m not going to go into each of these as the information on this formula is readily available.  The thing to understand is that each attribute is a value from 1 to 6 that represents a guess. (albeit an educated one)

What you will find in any traditional estimation system is something very similar to COCOMO II.  Tons of factors looking to measure this or that, complex formulas and a good mix of probability theory. In many cases today, this type of method simply won’t work.  Why? 

If we look at the challenges in quantifying each factor above we can begin to understand the reasons. 

A - Organizations change practices on a regular basis, fail to keep the necessary empirical data, face frequent significant technology changes.

B – Team membership changes which may impact team cohesion, varying degrees of market understanding and regular changes to the architecture driven by market demands.

M – Platform difficulty not understood early on, team changes effecting personal capabilities along with experience and poorly understood reuse model.

To wrap this all up, I thought it would be fun to consider our greyhound race being run as a modern software development project.  First, we are betting on not who wins the race, but how long it takes each dog to finish.  Further, we are going to change the track during the race (but we’ll announce it to the audience) and swap out dogs here and there to keep it interesting.(the dogs are just running right?)  :)  Anyone want to go to the track?

While I’m by no means advocating for companies to stop estimating, I am advocating for simpler, less risky and more cost effective models such as Planning Poker tied to Release and Sprint Planning coupled with a Product Roadmap.  These tools used with a good Agile approach are showing us a more sensible way forward.  I’ll try to explain some of the ideas around why we “bet on the dogs” along with some tools to help us move away from this in future posts.



A Successful Software Organization – Leadership Reading

clock January 31, 2010 05:20 by author Chad Albrecht

I am spending most of my time as of late providing management consulting services to my clients.  Most of them have made, or are making, the transition to Agile and often facing the same set of issues.  While I think there is no replacement for a good Management Consultant/Agile Coach, a close second is reading as much as you can from those who have successfully made the transition to Agile.  With that, I would like to present a select list of my favorites:

         


Using the ‘Release’ Concept in Agile

clock January 18, 2010 11:42 by author Chad Albrecht

I’m spending quite a bit of time these days helping organizations implement Agile methodologies.  As such I hear the same set of questions and see the same set of issues over and over again.  One of the issues I see quite often is the “long sprint.”  To explain what I mean by this I’ll use a hypothetical conversation with a Team Lead new to Agile.

 

Team Lead: “How do you deal with the fact sprint planning and reviews take so long?”

Me: “How long is long?”

Team Lead: “Sometimes a week!”

Me: “How long are your sprints?”

Team Lead: “Usually 3-6 weeks.”

Me: “How did you determine that 3-6 weeks was a good length?”

Team Lead: “Because we couldn’t spend 2 weeks out of every month not coding!  We use longer Sprints to avoid spending so much time in review and planning.”

 

For those of you that are experienced in Agile, you should see a few problems here.  For now, let’s just focus on the “long sprint” concept.  The “long sprint” seems to manifest in organizations that are always sprinting.  First off, this is in direct conflict with the name sprint.  Sprints should be just that, a focused exertion of energy over a short period of time…2-3 weeks max.  So how do we solve our Team Lead’s issue with spending too much time in review and planning and not enough time writing code?  Enter the “Release.”

A Release is a means of building larger blocks of functionality in multiple Sprints. (usually 4-6)  Some Agile methodologies (XP) implement this concept directly, others do not. (Scrum)  There are many reasons to use the concept of a Release, a select few are:

  • Some features just might not fit into a two week Sprint.
  • Allow team to perform work in parallel to development.  In general team members can do work other than sitting in sprint review and planning sessions.  This is because these sessions are lighter weight and involve fewer people.  You simply review implemented sprint functionality ensuring it meets the needs of the stakeholder and grab the next chunk of the prioritized Product Backlog. (ok, a bit more than that, but you get the point) These two sessions should not take more than 3 days.
  • Reduce the overhead of delivering software to production every 2 weeks.
  • Reduce the information overload caused by releasing every 2 weeks.
  • Define a delivery pace more inline with that of the organization. (the rope in the Drum-Buffer-Rope of Throughput Accounting)

The next logical question is “Do we create a Release Backlog?”  I agree with Mike Cohn in this case and would say no.  I do however, use the concept of a Release Plan or Release Roadmap.  According to Mike a Release Plan contains:

  • Graph showing historical velocity.
  • Prioritized Product Backlog. (including some big user stories, "epics")
  • A predicted range of where we will finish. This should be either a date-range for a fixed-scope project or a functionality-range.
  • Personnel assumptions. (Team members and availability)
  • Velocity assumptions. ("we’ll go about half speed during December because of holidays and time off")

I would also add the following:

  • A Vision Statement.  (“We want to add the shopping cart functionality and connect it to PayPal”)
  • Estimated Release Value as I discuss here.

Using the concept of a Release in Agile organizations can be an extremely effective way to increase efficiency through the elimination of waste.  I will try to post more on this topic in the future.  As always, let me know your thoughts.

Further Reading:

Extreme Programming Release Planning:

http://www.extremeprogramming.org/rules/planninggame.html

Mike Cohn on Release Planning:

http://blog.mountaingoatsoftware.com/why-do-release-planning

Mike Cohn on why there should not be a release backlog:

http://blog.mountaingoatsoftware.com/why-there-should-not-be-a-release-backlog

Kelly Waters on Release Planning:

http://www.agile-software-development.com/2008/02/agile-release-planning.html



Visual Studio 2010 Team Foundation Server Requirements Management Guidance

clock January 16, 2010 07:42 by author Chad Albrecht

I am happy to announce that we (Rangers) have released the new Requirements Management Guidance for TFS 2010!

This Ranger solution addresses the People, Process, and Technology guidance for Requirements Engineering (RE) using Team Foundation Server. The goal of this guidance is to provide formalized Microsoft field experience in the form of recommended procedures and processes, Visual Studio Team System and Team Foundation Server configurations, and skill development references for the Requirements Engineering discipline of your application lifecycle.

Visual Studio ALM Rangers
This guidance is created by the Rangers who have the mission to provide out of band solutions for missing features or guidance. This content was created with support from Microsoft Product Group, Microsoft Most Valued Professionals (MVPs) and technical specialists from technology communities around the globe, giving you a real-world view from the field, where the technology has been tested and used.

What is in the package?
Requirements Management is a vast area with many disciplines. To address your areas of interest and expertise, we have packaged the content in 9 zip files. The default download is the complete package in one zip file for those who are interested in all areas.


1. Introduction: RM Rangers Guide to the Complete Guide Start Here
2. Requirements Management Planning
3. Requirements Traceability
4. Analysis and Breakdown
5. Requirements Elicitation
6. Requirements Specification
7. Requirements Validation
8. Requirements Change Management and Approval
9. Requirements Management checklist sheet

 

Great job Mike Schimmel & the rest of the team!



New TFS Stadium Diagram

clock January 15, 2010 05:59 by author Chad Albrecht

For those of you out there doing TFS 2010 presentations and demos, here is the TFS “stadium graphic” with the new SKUs and branding.

image

Enjoy!



Scrum Sprint Monitor

clock January 13, 2010 04:18 by author Chad Albrecht

I have a couple of custom-written apps that allow teams to track current progress on a projector using TFS.  I just found a community project on CodePlex that looks like a promising replacement, Scrum Sprint Monitor.

Scrum Sprint Monitor provides the Agile team with hands-off, always up-to-date status of the current Sprint, both at the individual and team level. It is designed to run either on a large LCD screen located in a public area, or as a desktop application.

image

Looks like a great product!  If you try it, let me know what you think.



About me...

bio_headshot

I am a leader, entrepreneur, software engineer, husband, father, pilot and athlete. Over the last 17 years of my career I have built numerous successful companies and software development teams. This amazing journey has taken me all over the world and allowed me to work in a number of diverse industries. I have had the privilege to meet and work with thousands of unique and talented people. As you will see from my blog I am a strong believer in Agile techniques and the Kaizen corporate culture. I am always looking to grow myself, my teams and the companies I am partnered with.

Contact me... View Chad Albrecht's profile on LinkedIn Follow Chad Albrecht on Twitter Subscribe to this blog

Professional Scrum Trainer

Professional Scrum Developer Professional Scrum Master I Professional Scrum Master II Professional Product Owner I Professional Product Owner II Certified ScrumMaster

MCTS

Calendar

<<  February 2012  >>
MoTuWeThFrSaSu
303112345
6789101112
13141516171819
20212223242526
2728291234
567891011

View posts in large calendar

Blogroll

Download OPML file OPML

Sign in