Tag Archives: Software Process

What’s So Hard About Planning?

In the software business where most people don’t seem to agree on anything it seems that everybody agrees that planning is hard. (The only thing that seems to be even harder is tracking to the plan and regularly replanning, but that’s another story.)

Why is it that we have such a hard time with planning? Our thinking about the goals and benefits of planning seem to stay in our way. Here are four mistaken beliefs that many folks have and what can be done about them:

1. “It is not worth planning, life’s changing too fast.” Life is changing fast, but that doesn’t mean that it is not worth planning. It just means that we need to evolve the plans as things change. A plan at best represents your thinking in a moment in time. As you learn more, you need to improve on your plan.

2. “The only reason to plan is to figure out what the end date is, but they always give me the end-date anyway.” “They” might be the management, client, architect, team lead or that “other” team; you pick. Knowing the end date is good, but you still don’t know what’s included. Of course, you respond to this that: “they” also tell me what I have to build. However, “they” are unable to specify how much of those things to build. That is still up to you. It is up to you to figure it out how to make it happen. If you cannot find a way, at least you can tell “them” early that you will not be able to make this happen. And, you will be be able to back up your statement with a detailed plan that shows that you had thought through the problem.

3. “I cannot create a perfect plan.” Nor can anybody else. You need a plan at the level of granularity that can help you perform your work. You are creating this plan for yourself (or your team), hopefully not for others. Create something quick, then updated it “early and often.” The plan needs to represent your best knowledge at the moment you created it. Accept the fact that you will learn as the project progresses. Learn to live with incomplete data. These are key to your success as a software engineer.

4. “I don’t know how to plan. I am not given the opportunity to go to a class to learn it.” Nobody was born with perfect planning skills. You may have the natural talent to think through problems with incomplete data (which helps), but everybody can learn the mechanics of planning and everybody can become pretty good at it. It is your responsibility to seek out learning opportunities. Let’s face it: nobody has your interests at heart more than you do. So, it is your job to find ways to improve your skills. Once you learned the basics, then keep practicing.

To sum it up: A plan is a roadmap to project completion. Just like any other map: “when the map and the terrain don’t agree, trust the terrain” and update the map. Planning is an acquired skill. With practice you can get good at it and you will derive benefits to make it worth learning it.

More on Prototyping

To convert the unknowns into knowns, you need to aggressively prototype.

What to Prototype?

Here are some examples:

Prototype the use of an API. Create a prototype to see if the API that you need to use works the way you think it does. This includes confirming that it can be called with parameters of the type and range that you can provide. The API may belong to a component that one of your team mates wrote, or it may belong to a third party library. Either way, you want to be absolutely certain about how to use it. No amount of documentation reading will substitute for a well pointed prototype.

Prototype an algorithm. Create a prototype to prove to yourself beyond reasonable doubt that you can implement the solution to a problem.

Prototype an interaction. Create a prototype to show that the interaction sequence or method that you want to use in your application actually works for the intended use. You can take the prototype and usability test it, incorporate the feedback, and then place it into your application.

What should the prototype look like?

Since we are talking about software development, your prototype should be a software program. A small program. As small as possible. A program that answers one or two critical questions and that’s it.

The prototype should be like the small program that you write to prove to the API writers that their API has a defect. It has to be small and prove one point. Your objective from the prototype to learn something that you didn’t know, or confirm something that you suspected.

How to Prototype?

Pick one or two key questions that you want your prototype to answer and focus your small program answer them. Keep in mind common software engineering and experimentation principles as you decide on how to proceed:

  1. divide & conquer: write multiple prototypes as needed
  2. reduce scope: keep the scope of each prototype to a minimum
  3. isolate concerns: separate the concerns so that you can establish root cause
  4. confirm behavior: confirm that an API behaves exactly the way you had thought that it would under the conditions that you anticipate
  5. validate assumptions: validate that what you think is true, it is indeed so
  6. validate invariants, pre- and post-conditions: half the battle is to identify these; you get extra credit for validating them

I have noticed that after a while some prototypes that started out with the best of intentions, become monsters. Don’t be tempted to stick another one or two topics into an existing prototype. Your prototype will become so complicated that you cannot confirm root causes for outcomes. Then you lost your ability to know things for sure.

Lastly: the most important rule is a well worn one: KISS=Keep It Simple & Sufficient.

Why Prototype?

Every once in a while I am surprised by somebody who says that prototyping is such a waste of time. For quite some time I have taken for granted that prototyping is a fact of my software engineering life. Maybe it is worth asking: what is the problem for which prototyping is the answer? Or, in other words: why should you prototype?

You should prototype when you don’t know enough about about the problem. Which is almost always. When your knowledge is lacking in some aspect, then it is time to write a prototype. When you don’t know enough about an API, some requirement, the operating system that you are designing for, the libraries that you want to use, and so on. When you feel that you have to answer a few clarifying questions, then it is time to answer them with a prototype.

The short answer is that you prototype because you don’t know enough to proceed with the project at an acceptable level of risk.

Living with Constraints

Life, especially software development life, is never without constraints.

Time Constraints

  1. The software has to be released on a certain date, set well in advance. The only option is to plan based on the time budget.
  2. Given that I have this much time, what can I fit into this time?

Software Correctness (or Incorrectness) Constraints

  1. The software that you work with has flaws in it.
  2. How many flaws?
  3. Are the flaws of the software making it unusable? This is not any different than any other software you are trying to use. Windows has flaws in it, however once a problem is discovered, you are always trying to use the program in a way as to avoid that particular flaw.

Incomplete Knowledge Constraints (Requirements -> Problem -> Solution)

  1. The understanding of the requirements will evolve as you move through the project. More so, even the understanding of the folks who specify requirements will evolve.
  2. Your understanding of the problem evolves.
  3. Your understanding of the solution evolves.

Each constraint requires a different treatment. Each poses risk, therefore each needs to be dealt with, or the project will get into jeopardy. The questions to ask about each are:

Time Constraints

  1. What can I do in 2/20/200 hours?
  2. What % of my time should I spent on a given activity?
  3. What is the activity that only I can do?
  4. What is the activity that I can do that is visible?
  5. What are those activities that I can do to reduce other’s dependencies on me?
  6. What can I finish now to unblock to others?

Software Correctness

  1. Do I have proof in form of running code that this API I want to use works in the way I want to use it?
  2. Given that I found a problem with this API, is there a workaround that I can use?

Knowledge Constraints

  1. What are the requirements that are at risk to change because of real or perceived lack of clarity/definition/etc.?
  2. Is the problem formally described? If not, why not?
  3. Is the solution presented on paper proven to be correct (empirically or mathematically/logically)?
  4. Does the solution provide flexibility to cover for the risk of changing requirements?

People’s Skill and Knowledge Constraints

  1. What are the skills available in the team?
  2. What are the growth goals for the people on the team?

There is no constraint-free state. Our job as software engineers is to figure out a solution that can be completed within the constraints of time, people, money, etc. that we have. It is not an easy task, but that’s what makes it fun.

Getting Started with Software Reviews

Summary

  1. The purpose of the design and code reviews is to find defects.
  2. The factor that most influences the length of a design or code review is the amount of work product that has to be reviewed. This may be pages of design or lines of code of source.
  3. Checklist-directed reviews are the most effective at finding defects specific to the project and product. The checklist has to be built from past defects that the person or team had problems with most recently.

Starting a Review Practice in a Team

Checklist-directed reviews have a 70% to 90% yield in finding defects. The yield is defined as the percentage of defects found by the review that existed in the work product on entry into the review. When a team starts a review practice, there is no checklist yet. How can a Team get started? Here are some tips to get the reviews going.

What parts of the system to target for a review?

  1. Create on a large piece of paper, or on a whiteboard, a map of the system that the team is working on.
    1. This map must include at least all the physical modules of the system, but going to a finer level of detail is better.
    2. Each system part drawn should represent around 2 KLOC of NCSS (KLOC=thousand lines of code, NCSS=Non Comment Source Statement).
  2. Review the defect log.
    1. From the defect log select the most recent list of 100 defects (or whatever you have in the last month).
  3. Place a mark by each system part for each defect that can be traced to that part.

The system part with the most marks gets to be the target of the investigation.

If after a cursory assessment it seems that finding and fixing all the defects in the part would take longer then rewriting it, then the team should choose the rewrite route.

How much code can you review?

The speed of the review seems to be constant on all projects. Ranges from about 200 to 300 NCSS per hour. Reviewing at higher speeds will make the reviewers miss what they are looking for.

What is the difference between a review and defect finding?

During the review the reviewer is looking at the source code, and when he/she notices a defect he is looking at it right then and there. There is no more detection needed. On the other hand, when the developer has to investigate a defect that is reported by a Customer, then first the reason for the defect must be established. This is a time consuming activity because it contains a great deal of uncertainty.

What to look for in a review?

It is best to look for defects that had been observed already. Chances are that the defects that were noted in some part of the system, are present in some other part of the system as well (especially if they both have just been worked on).

Types of Reviews

  1. Personal Review
  2. Peer Review
  3. Inspection
  4. Walkthrough

Review Principles

Personal reviews follow a process with

  • entry and exit criteria
  • a defined review structure
  • guidelines, checklists, and standards

The personal review goal is to find every defect before the first unit test. To address this goal:

  • use coding standards
  • use design completeness criteria
  • measure and improve your review process

Design Review Principles

  1. Produce designs that can be reviewed.
  2. Follow an explicit review strategy.
  3. Review the design in stages.
  4. Verify that the logic correctly implements the requirements.

What is a Reviewable Design?

A reviewable design has:

  1. defined context
  2. precise representation
  3. consistent and clear structure

This suggests that:

  1. the design’s purpose and function is explicitly stated
  2. you have criteria for design completeness
  3. the design is explicitly structured in logical elements

Checklists

Checklists: The Theory

  1. When performing precise tasks, it is difficult to do more than one thing well at a time.
  2. The checklist defines the review steps in the suggested order for performing them.
  3. By checking off each item, you are more likely to perform it properly.
  4. Establish a personal checklist that is customized to your defect experience.
  5. Process yield is the percentage of defects found before the first unit test execution. (70%+)

Checklists: HOWTO

  1. Use your review strategy.
  2. Review one product component at a time.
  3. Check for one type of defect at a time.

Checklists: The Key Point!

Treat each check as a personal certification that the product is free of this defect.

For Extra Credit: Estimating Remaining Defects After a Peer Review

Use the Capture-Recapture Method:

  • A: The number of defects found by the first reviewer.
  • B: The number of defects found by the second reviewer.
  • C: The number of defect found by both the first and the second reviewer.

Estimated total number of defects in the product: E = A * B / C
Total defects found so far: D = A + B – C
Estimated remaining defects in the product: R = E – D = (A * B / C) – (A + B – C)
Inspection Yield: Y = D / E * 100

HOWTO Quick Summary

  1. Pick a piece of code that you are uneasy about.
  2. Review it for defects that you had recently. KEEP A LIST!
  3. Keep your review speed at 200 LOC/hr. Plan ahead!
  4. Only look for one defect at a time.
  5. Treat each check as a personal certification that the product is free of this defect.

See Also

Guiding Principles for Reviews from Wiegers

  1. Check your egos at the door (Weinberg)
  2. Keep the review team small.
  3. Find problems during reviews, but don’t try to solve them.
  4. Limit review meetings to about two hours.
  5. Review only about 200 to 400 NCSS per hour.
  6. Start the reviews where the perceived pain is the greatest.
  7. “It is only a mistake if it gets out of the review.”
  8. “Avoid using technical reviewers who are themselves ‘above’ review.”

References

  1. Peer Reviews in Software, by Karl Wiegers
  2. Introduction to the Team Software Process, by Watts Humphrey
  3. When two eyes aren’t enough, by Karl Wiegers
  4. Seven Thruths About Peer Reviews, by Karl Wiegers
  5. Seven Deadly Sins of Software Reviews, by Karl Wiegers
  6. Handbook of Walkthroughs, Inspections and Technical Reviews, by Freedman and Weinberg