SOFTDEV: Measure what you develop; make it part of your process

Every software methodology tries to incorporate estimates/actuals and variance reports. By the time you get to SCRUM or very agile methodologies, you should be measuring your team’s velocity. You might be looking at the backlog count & estimates, the tasks per sprint, time for a sprint and the number of sprints … but you are measuring.

In my career, one of the biggest lessons is measure everything. If you don’t measure your project (a) you can only guess at completion dates; (b) you will not improve; (c) you will have issues with management and/or customers. I’m not talking about measuring the number of lines of code or anything that crude – I’m talking about measuring what’s important to your organization.

I have heard it argued that the difference between a software development team and a software engineering team is that engineers track and measure their results scientifically. You might argue that the creative side of software design is more an art than a science but software development can be measured and you (your team) will be better off for doing that measurement, and reviewing that data to improve the next time through a software cycle. Measurement is good. Even Art is comparatively measured, so be creative and chose the metrics that fit your team, but take the time to measure.

For improving development of requirements, I suggest you measure the number of tasks per requirement (as defined by an Epic or Story). During your sprint/release retrospective meeting review the metrics and decide if requirements are clear enough or need to be broken into separate pieces. This will improve the product owner’s ability to define the requirements and will clarify the outstanding backlog items related to this requirement. You can also review the requirements outstanding during the sprint retrospective or at the end of the sprint demo meeting to determine if they are still needed and relative order of importance. Reducing requirements and measuring that over the course of the sprints to release gives you a good measure of the focus and respective understanding of your audience.

If you start with 20 requirements for a product and only deliver on 10, or more typically, start with 10 and go to 20, perhaps your method for collecting those requirements should change. One way to do that is with better Voice of the Customer requirements gathering or appointing several of the technical sales team to represent your primary audience in coordination with your product owner, so you avoid feature creep. Beware however, that during development insights can be gleaned from showing a sprint demo’s results that lead to innovative ideas – you don’t want your process to stymie innovation – revising a requirement during iteration is one of the best characteristics of Scrum!

Speedometer photoI like to measure the backlog items outstanding vs sprint items accomplished. Scrum is all about velocity. Completing more tasks of the same difficulty as compared to earlier sprints, is a great measure of your velocity. Of course, this can have a subjective component unless time estimates vs actuals on tasks are tracked and measured.

For improving sprint planning, your retrospectives should always review the task estimates vs actuals. As you are planning a sprint, you should add in-context estimates (estimates based on what has been done before, and what dependencies exist for this task in this sprint). Another related metric is the delta between initial estimate in the backlog item and the in-context estimate during the sprint planning. The accuracy of those estimates are essential to improving the sprint plans and managing scrum team members’ ability to estimate improves their skills as software engineers.

There is also a whole category of testing metrics that are necessary – test failures, escape rates, blocking issues, static analysis results, code reviews, code to test failures (for weak areas in the code), repeat failures (the number of develop/test cycles for a task), build failures, etc. All these are essential to good quality code and can be an objective way to look at effectiveness of your team.

Warning: metrics should always be used to improve your team and product releases, not as a weapon for performance discussions. If you start evaluating your team’s performance, salary or bonus on the process metrics you will almost always see your team “play” the metrics which will have a terrible effect on your team and product release. Rather, use the metrics above to establish a path for each member’s success and remember that your primary goal should be to produce high quality innovative product that thrills customers. If you know your team well enough you will assign the right backlog items to the right people and over time raise the performance of every member.

While this post does not include a comprehensive list of metrics for software development teams, I have listed the ones I’ve found to be most effective.

I’d love to hear from you on your metrics used to build great products – please feel free to comment on this post and don’t forget to subscribe.

 

SOFTDEV: Top 10 software practices

SOFTDEV: Software Development Methodologies

One of the categories in this Blog is about Software Development Methodologies. From a single person project to hundreds of developers there are some key similarities and some significant differences. Also, the evolution of the art of software development and the science of software engineering have changed the processes used. Finally, the tools we have to work with have evolved and improved significantly.

I’ve been programming since 1974 (see BIO – Programming in School). Sure my initial projects were in high-school and structured around basic programming fundamentals but even in my teacher’s classroom, there was structure and a set of expectations. My teacher insisted on commented code or you got a zero grade and she encouraged us to write the comments before the code … and remember, each line of code was a keypunch card back then.
We’ve come a long way since the 1970’s, even if you are a project team of one person, but we have not outlived the usefulness of good software practices:

  1. Understand your user’s requirements;
  2. Design your code before you write your code;
  3. Comment your code well;
  4. Make your code readable to others.

I’ll add to those basic principles some practices that bring us into this century and more into a team development perspective:

  1. Build tests as you build your software;
  2. Use a version control system (CVS, Subversion, git, etc.);
  3. Define a build system that versions the builds tied to the version control system;
  4. Iterate fast, and demonstrate working, tested code, even if it’s not the entire feature or product;
  5. Always make your project measurable;
  6. Communicate your completion estimates weekly to management, to customers or the intended users.

There is a lot written about software methodologies like Waterfall, Agile, SCRUM and Kanban among others and they encompass the majority of the principles listed above along with the concept of self-organized teams to get things done, on-time, on-budget, with happy customers and employees.

I want to explore some of the more challenging aspects of software development methodologies from my own experience and talk about the challenge of transitioning from one process to another for continuous improvement.

BIO: Programming in School

I was a very fortunate student going to a great high-school with the privilege of access to a IBM 1130 computing system on the second floor.

IBM 1130 photo
Photo by Martin Skøtt
Once you showed the teacher you were competent, she gave after-hours access to the computer room and a bunch of us nerds hung out and learned to program. First in assembler, then in Fortran. If you were real good you got to switch the language pack in a large DASD (which was replaced by floppy disks). Only the teacher bootstrapped the computer with the paper-tape. As I recall she was worried we’d tear it. I learned to type on a keypunch in that classroom and to program. I made a personal swimming log program (I was a competitive swimmer) and I made a cribbage game I could play with the computer using dip switches on the console. Okay they were rudimentary but I was a programmer before push button telephones were common.

Even doing a project on your own, you establish programming styles and expectations so others can read and understand your code. My teacher insisted on commented code or you got a zero grade and she encouraged us to write the comments before the code … and remember, each line of code was a keypunch card back then.

Even when I got to University of Toronto, most of my class projects were done on keypunch cards. Only in my upper classman years did I use a PDP11 with VT100 terminals and 3270 green screen terminals with mainframes. In 1980 I got my hands on an Apple II and from that summer on, I’ve had personal computers in my dorm, home and office. I think I had the first PC in our dorm in 1980 and I did all my senior papers on that Apple II (yes, with the shift key modification).

VT100 Terminal photo
Photo by vegms

IBM 3270 photo
Photo by vaxomatic

If you’ve ever read the Outliers by Malcolm Gladwell, you know about the 10,000 hour rule. Despite newer studies to the contrary, I still believe that rule to be true. I had more than 500 hours more than every other Computer Science student when I started College. By the time I graduated with 2 summer internships, I think I must have been close to 8,000 hours. I was promoted to project lead on a 50 person project when I was just two years out of school and by then I easily had 10,000 hours. I won’t go as far as to say I’m a Guru in anything but I am certainly accomplished, in part because some educator negotiated to get a computer put into our high-school and a high-school freshman nerd found his groove.