Wednesday, September 29

Endless Iterations

S ome time ago I sat in on two iteration meetings for an adjacent team. There was a possibility that I would join the team on a part time basis, a possibility that never eventuated.

The project they were working on was already quite far along. They claimed to be using eXtreme Programming,  to be agile, and to follow two-week iterations. However:
  • The team were not asked to commit to completing the tasks scheduled the iteration planning meeting.
  • The instead of scheduling based on the historical progress of the team in previous iterations the capacity of the iteration is simply assumed to be 80 hours times the number of developers.
  • Defects from failed acceptance tests were postponed until the end of the release, leading to a final “test and fix” phase.
  • Rather than using rolling wave planning and progressive elaboration, all stories were assigned to specific iterations during the initial release planning phase.
  • There was no closing ceremony for the iteration—no demonstration of completed functionality, no interim retrospective. Unfinished tasks were simply moved to the next iteration, and planning for the new one began immediately.
  • There was no learning from one iteration to the next. Mistakes were repeated, and any lessons learned were quickly forgotten in the rush to complete tasks.

The point of time boxing is to
  • Provide risk management 
  • Limit the time spent on any one task
  • Habituate the team to meet deadlines.
  • Avoid wasting time on sunk costs
None of these objectives were being met. 
They were continually starting but never finishing

Monday, September 27

Sticky Code

I was working with though some legacy code when I discovered that the original coder had
  • avoided magic numbers by using Macros which was good
  • defined the Macros in multiple places which was bad

Tracing the Root Cause

To understand why this duplication happened, I started asking myself a series of "why" questions:

 
Why was the macro duplicated? 
Because the original location of the definition was poorly chosen, and later developers were reluctant to move it.

Why were they reluctant to move it?
Because moving a definition requires deleting it from its original location.

Why the hesitation to delete code? 
Several possible reasons:
  • They didn’t have proper source control.
  • Their source control system didn’t clean up deleted files from the workspace.
  • They lacked sufficient test coverage to feel confident in making changes.

Why This Matters

Code definitions and implementations need to be free to move between modules and libraries as a system evolves. If they aren't, you’ll eventually end up with duplicated logic, circular dependencies — or both.

In short, good architecture requires not just clean code, but also the courage and tooling to move and delete it when necessary.

Related Posts