Meditation

In answering these questions please think of a project as a whole and not just of the parts you did.

Consider the last 12 months:

Write down 3 things that went well Write down 3 things that went badly

Did the Customer change their mind?

Give one instance.

Did you learn how to do something better and hence went back and changed some code?

Did you re-structure some architectural aspects?

If so, why?

Immediately after a release did you find that there was a mis-communication and something had been done under a mis-understanding?

That is, did you deliver "correct" but irrelevant code?

Did you write any features only to find that they were not used?

Were those features the customer’s ideas or your generalisation?

While coding, did you need to pause until a customer could answer a question?

Did you just use your common sense and carry on?

Were you right?

Can written material ever be a better source of understanding than face-to-face talk at a white board?

Did you test every line of code that you wrote yourself?

What components and for what reason did you leave any testing to QA?

Did QA find any defects?

How do you know that your code has been tested "properly" or "enough"?

What lines of code would you never test as a programmer?

Do you code to a clear set of standards?

Are they in writing? Does everyone use the same standards?

What was the longest interval between completing coding and use in the field (possibly by a pilot site)?

What was the shortest interval?

When is the simplest solution not good enough?

What makes things that start off being simple get complicated?

What is your typical period of concentration – 1 hour, 2, 3 or whole days?

When you last had a really long period of cutting code very productively what was true?

When you last had trouble concentrating what was true?

When did you last have a conflict in the build (what you did screwed up someone else or vv)?

Why was all the bad code written by people who have left?

Do you hate fixing other peoples code? Why?

How do you estimate code and debugging time?

When were you last out by 50% over-run? Why?

Can you conceive of writing code which during development is always defect free (although incomplete)?