I have come to realize that there are basically three stages in things that require thinking, repeated continuously. It’s like the Buddhist eternal cycle. It begins anew with every new skill, and if one does not bother to build upon the previous experience and attempt to acheive the next level of coding existence, the only fate that awaits it the inevitable repetation of the past.
To ground things a bit, let’s walk this path in the context of disciplines in computer science. Computer science, for my purposes, is not a discipline but a field within which many disciplines dwell. Coding python or java, designing a CMS or a multimedia app, or creating a security aware or high availablility system is a discipline. Each discipline requires a slightly different mindset. This differentiates it from a field, which only requires some basic understanding of the logical underlayments of the field. So let us choose a discipline and proceed.
The first steps is almost always the logical soup stage. The logical soup stage is exemplified by a lack of logical and functional structure, combined with an intuitive exploration of the space. In reality, it is a search for structure — the stumblings in the dark that may allow a blind man to describe an elephant. Through the haze, one can glimpse facets of the structure that should, or perhaps could, be. Often, there is neither time not opprotunity to grasp or fully implement the perceived structure, but these glimpses inspire nonetheless. The final product operates at merely a functional level — nothing more.
The second stage derives from the first, and this incarnation is the straightjacket stage. This stage is fraught with an overabundance of structure. Contemplating the structure glimpsed in the first stage, the creator now attempts to solidify the glimpses into rules and patterns. The internalization of a bewildering array of often-conflicting rules leads to the creating of even more rules to unify the varying models. The overstructuralized product trades off intuitiveness for generality, creating a product which could be infinitely extensible, but in reality would require far too much effort to extend due to the multitude of rules one must contend with. The structure nonetheless provides benefits beyond function, and the code is now not only functional, but in some ways understandable.
The final stage derives, as again, from the previous. The creator, feeling suffocated by rules and constraints, in some sense rebels against the structure. Experience now truly comes into play, and intuitiveness returns, accompanied by a critical reflection on structure. In this stage, there is a tention between intuitiveness and structure, and an understanding of moderation is both directions. The moderation leads to two levels of rules. The first level is the sort of rules seen in the straightjacket stage, specifying the logical structure of things. The second level is new, and specifies meta-rules for applying structural rules. These rules allow others to grasp the creator’s reasoning, and infer rules even when the rule is not written down. Unlike the straighjacket stage, the code is now not only carries meaning, but intent and vision.
Though I said earlier that any mental discipline would do, I chose coding for a reason. Coding is in many ways not so different from anything thinking. It’s a dual-purpose discourse. While ostensibly speaking to the machine, code also speaks to those who read the code (be it the original writer or another reader). This is also true for acts of thought, and research in particular. When we do research, we contemplate matters not only for ourselves, but also for others. When we create frameworks, material or mental, we as again speak not only to our own needs, but to others as well. When we think, these thoughts are of little value to the universe unless actualized by action.
If coding is like thought, then it’s also clear that thought has structure and substance, form and function, affordance and legibility, and many other things more easily attributable to code in common parlance than to thought. And like coding disciplines, substantial thought along any avenue is multi-staged. It also starts as a soup of ideas, first intuitively felt, then structured, then relaxed and re-intuited into a final form. The thoughts thus produced in the final steps have the same dual structure that code has in its final evolution, and carry both the information we can convey in words, and the feelings we can convey over those words. The benefits of the evolution of code, as well as the pitfalls that come from these stages, can thus all apply.
Already this entry grows rather long, so I shall lay out the rest of my thoughts on the stages of thinking in my next post, The Nirvana of Thoughts.