programming, fast
By programming fast here I speak about the effortless act of producing working or semi-working code. This happens without having to stop too much to ponder and plan how to implement something. On a more larger, architectural scale, this manifests as a direct understanding on how to structure software. For example, knowing what design pattern to use where, what things to decouple, and eventually what to just declare good enough.
This is something that is usually developed through years of practice and experience. The experience is generally gathered from simply programming, but perhaps also by other means of general logical thinking. It is a way of working where something just feels right, where one can rely on intuition and common sense.
trustworthiness of intuition #
Intuition can more likely be trusted when the environment or context is regular enough. For intuitive predictions to be accurate, the predictor needs to have enough experience and knowledge about the given environment. A person can experience intuition in highly dynamic environments, but there is a higher chance of coming to wrong conclusions and providing a solution to a wrong problem.
People are not made for statistical thinking. They tend to substitute, simplify or think up analogies to explain the dry number to themselves. They are also unaware of randomness, and tend to look for causalities where they really do not exist.
some manifestations of expertise #
With enough experience, one can detect the point of “sufficacy”, meaning the sufficient efficiency of the code base. Too much improvement and optimisation will rarely raise the value of the end product, and naturally takes up more time.
Then there’s the occasional hurry where one takes shortcuts due to a time constraint or a straight up disaster. In this case, the speed of producing code isn’t usually the fluent and effortless kind, and is likely to worsen the situation. This time, the expertise can help in making the right decisions to overcome the hurry and ease the potential panicking.
With experience, one is prone to develop confidence. Making condifent and succesful decisions can lead to a self serving feedback loop, generating more confidence as the effects builds on itself. This can have a dangerous effect if that success is based on chance, as “false” confidence can lead to undesirable decisions.
Thinking fast, intuition, common sense, etc. happen all in “System 1”, which means they happen without purposeful thinking, and in an instant. It is automatic, and generally cannot be circumvented. This fast generation of thoughts and opinions is susceptible to different cognitive biases, of which one would benefit to be aware of.
Software development is generally thought of a “System 2” (slow and effortful) type of profession, but the fast decisions and thoughts should not be forgotten. As experience builds, one can begin to trust their gut and actually make better judgements without thinking too much and overanalysing.
Ideas from