I’m working as one of a team of coaches for a large client where we are introducing a basic “agile” development model. The external coaches and internal (client) mentors are having an off-site event soon to improve our cohesiveness as a team.
One of the things we’re doing to prepare for the event is to take an online self-assessment known as StrengthsFinder, offered by Gallup and based on the book, Strengths Finder 2.0 by Tom Rath. Unfortunately, my top five strengths are:
I say “unfortunately” because I can’t just let the assessment run its course. I feel compelled to take it apart, no doubt as a direct consequence of these particular “strengths.” Continue reading We simple folk
The Iron Triangle of scope, schedule, and budget is fundamental to managing software delivery initiatives. Two general approaches are available for managing this aspect of delivery. With the traditional approach, we try to identify all needs, risks, and costs in advance and create a detailed, comprehensive plan before beginning development. With the adaptive approach, we begin with a vision for the product and incrementally evolve the solution based on feedback from stakeholders. Either way, we must deal with scope, schedule, and budget. However, the mechanisms we use are very different with each approach, and the metrics we can use to steer the initiative are different as well.
There are two key factors to consider when choosing an adaptive or traditional approach to Iron Triangle management: Urgency and uncertainty. Generally speaking, when either urgency or uncertainty is high, an adaptive approach is called for. When both urgency and uncertainty are low, a traditional approach is called for. It’s only fair to say that the choice is not always obvious.
Continue reading Choosing between traditional and adaptive development
In the past five months or so, I have been in on-again, off-again negotiations with a prospective client to participate in fairly large-scale organizational transformation initiative. The engagement would involve coaching, mentoring, training, consulting with management, travel to interesting cities, the chance to introduce effective methods to some 1,200 people, and the opportunity to work closely with some of the top people in the field. The agreed daily rate was just sufficient to cover expenses in the pricey home city of New York and still provide nominal income. Everyone involved was enthusiastic. We signed. I started to outlay cash to arrange for housing, and purchased the initial airline ticket.
With less than 24 hours remaining until flight time, a new manager took over at the client company. He abruptly terminated the entire organizational improvement initiative and all associated contracts.
This sort of thing happens from time to time. It isn’t the sudden reversal that caught my attention. Something else about the situation piqued my curiosity. It has nothing to do with the client, although one might justifiably question their handling of the matter. It has to do with the way I arrived at the decision to accept the engagement.
Continue reading Intuition and cognitive bias
A post on this blog received a very interesting comment from a reader with the nom de pixel Malapine:
"…my problem isn’t boredom but fear: the codebase sucks, we have no idea whether the features are what customers want, and if the product doesn’t sell, some of us may get laid off. If that’s ever me, I am screwed: my resume will show two decades with the same employer, the vast majority of it on Waterfall or ScrumBut projects."
"Off the job, I read books on Agile, go to monthly dojos, etc.; but on the job I can’t even do TDD properly — builds take 20 minutes just to compile, and nobody else seems to care."
I felt this called for more than a response in the comment thread. It seems to me it illustrates that perception can be more important than reality, and that is of interest to me presently.
Continue reading Perception
This post could be subtitled, "A self-indulgent look at past writings."
In April of 2012, Paul Bowler (@spbowler) found some articles from my old site on the Wayback Machine and tweeted about it. I replied to him, "Thanks for finding that! Some of the articles make me smile; learned a thing or 2 since then. Others I’m glad to have recovered." That prompted him to ask, "Which articles should I avoid?" That’s not a question to be answered in 140 charcters.
The short answer is that people should read whatever they think will be interesting, and then use their own brains to arrive at independent conclusions. I’m not one of those people who insists that others provide published references to support everything they say or write. If anything, I’d rather people did their own thinking, and used published references as references rather than as a substitute for their own brains. I’m not so sure published references are all that special, anyway.
Now for the long answer.
Continue reading With the benefit (and bias) of hindsight
I have learned quite a lot from reading Lean Software Engineering, a website authored by Corey Ladas. Although I am not personally acquainted with him, I have gained a great deal of respect for his thinking and his experiences in applying lean principles to software development.
My growing respect for him may be the reason I was struck by a comment of his that I came across recently while browsing the site. In a response to a reader’s comment dated January 7, 2008, he wrote: “Pair programming is antithetical to Lean” It was just a flat assertion with no explanation.
I was puzzled. Lean software development doesn’t speak to particular development practices, as far as I know. What might cause a practice to be antithetical to lean or, for that matter, to support lean? The only basis I could think of on which to reach such a conclusion was that the practice either hinders or helps us in applying lean principles to software development. Corey did not provide the same level of careful analysis and explanation as he does with most of the useful material on his site, so I decided to reason through the question myself.
Continue reading Pair programming and lean software development