Thinking while you are doing

There are three ways to think about what you do:

  • Thinking what you are going to do
  • Thinking while you are doing
  • Thinking after you are done

Software engineers tend to put a lot of vocal mindshare on the first and the last. The thinking while you are doing is gaining momentum but still lacking a lot of structure and explicit place in many projects I see.

Thinking upfront might be overrated but is still important. The upfront thinking should be limited to getting the fundamentals right. Fundamentals defined as choices that are very hard to change and fix later on.

When you have the fundamentals, you can start programming. While you are programming you have to make choices. All the time. Choices can and should be under constant evaluation. Do not attempt to get your code exactly right the first time, attempt to get it good enough. If you find it can and must be done better you can refactor. Tools like eclipse provide great assistance in refactoring, use them. 

Thinking while doing also means you have no dogmas: we always do it this way because it is our standard, period. The standard is the starting point, constant evaluation should be the compass if your  the standard is valid in a specific situation. If not deviate from it.

Thinking while you are doing is for me at very heart of the agile movement. Agile stresses that you should not think about things you do not need (yet). Daily stand up meetings are an example of formalization of “thinking-while-you-are-doing”. There is a constant, plan, do, check, act circle going on.

More on the thinking-after-you-are-done later.


%d bloggers like this: