How Do We Know What We Know (3)? 

When people invest heavily in a particular frame of thought, it can become how they think—it can become the framework they use to evaluate other ideas.  If these other ideas sufficiently contradict this framework, they cannot properly understand the ideas without compromising the framework.  

Languages and Thought
A simple example: I am an English speaker and know absolutely no Hungarian.  If someone explains something to me in Hungarian, it is largely impossible for me to understand—the information contradicts the language model I use.  I have worked with software engineers who cut their teeth on UNIX command-line and assembly programming languages who actively dislike and disparage graphical user interfaces, especially for programming.  Equally, those engineers who have learned programming using high-level programming languages with GUI IDE (Graphic User Interface Integrated Development Environment) supported languages can be seriously challenged by assembly-level programming.  It is not that they are less intelligent than the UNIX digit-heads, it is simply that this is not how they have learned to think.  Even more problematic is that, while the existing cognitive framework may inhibit true understanding of ideas that do not fit within the framework, they may result in rejection of the ideas themselves.

Languages and Systems Engineering
Another example from modern systems development is that much emphasis is put on learning programming languages rather than systems engineering.  This causes problems.  Most programming languages lean heavily on the same mechanism we use to read text.  Reading anything is a simple, single-tasking, control-sequenced, place-holding, linear process.  When people learn about computing through programming languages, they adopt that paradigm as their way of understanding systems.  Unfortunately, they are then somewhat forced to understand the system as if it were simple, single-tasking, control-sequenced, place-holding, and linear.  This thinking mechanism is a natural cognitive process for humans.  In fact, this is why our writing and reading mechanisms look the way they do—if reading didn’t map closely onto a primary cognitive mechanism, we would have invented something else [1].  The problem for programmers in building modern computer systems, is that modern computer systems are not simple, single-tasking, and linear.  Systems used to be like that back in the 1960s and 1970s but modern systems are complex, multi-tasking, and event-driven. 

When programmers try to understand complex, multi-tasking systems using a simple, single-tasking, linear, thought mechanism, they get it wrong.  Or more correctly, they think they do understand and then try to build systems as if they really do fit their cognitive paradigm.  So they build small, linear sequential, control-sequenced, single-tasking units, which do not function well when assembled into large, complex, event-driven, multi-tasking systems.  The challenge is we don’t have a good complex, multi-tasking, non-linear way of processing information, do we?  Well no, actually, we do.  But we have to enable it and we have to use it.  This is something we will discuss later.

What We Don't Know
So, internally, we only know what we know by applying what we know to what we know.  This is one of the reasons we tend to over-estimate our knowledge.  If we compare what we know against what we know there is always a very good match!  In assessing what we don’t know, we are comparing what we do know to what with think we don’t know.  Unfortunately, what we think we don’t know is also something that, in a sense, we do know [2].  If we compare what we know against something that conflicts too much with our existing body of knowledge, it can be very difficult to even work toward an understanding.

To compound the problem of assessing our own knowledge, we are not only attempting to estimate what we know against, well, what we know, we are using a comparison process that we’ve also built up through our learning.  I addressed this earlier: any evaluation of knowledge requires (a) something against which to compare and (b) a mechanism for comparing.  Unfortunately, when assessing our own knowledge, both the comparison source and comparison process are innate to us.

This is a self-referential assessment, and it means that we cannot empirically determine if what we know is “correct” and is another example of the circular reasoning we encounter whenever we think about knowledge.  This is also the reason why functional skill and knowledge assessments are usually not left up to the person being assessed.  If it were, we would all award ourselves graduate degrees since we are truly expert in what we know.

There are mechanisms to test our knowledge of course.  The college exam system is one such.  And there are also mind-sets we can adopt that help us avoid the self-assessment trap. 

This self-assessment trap can lead us into seriously incompetent behaviors when we are confronted with situations where there are things we actually don’t know.

FOOTNOTES

[1] It also explains why the human brain processes pictures and text quite differently and we have to learn to read text, whereas we do not have to learn to view and process images.

[2] I will address this challenge when I talk about Orders of Ignorance.