Okay... So, I wrote this a while ago during finals week, and I never published it. It was the night before my OS exam, and I spent more time writing this than preparing for my exam. It was an interesting train of thought, but I never went back to complete it. In any case, here's a work-in-progress article.
The Life Function
Understanding humans and their nature is something that philosophers have observed and criticized for ages. See, if humans were programs, how would they execute? How could we even begin to model them? In order to better understand that, we need to debug a program that is running.
Is life a
dynamic or a
static program? How do humans go about making decisions: should logic prevail over emotions? How are emotions generated? How do consciousness and self-awareness determine the constructs of the program. Time is a driving force, but we can't travel back, how does that factor into execution? Is death just an
unhandled exception that is a result of an overlooked edge condition or unfortunate fate.
Determining how functions are executed?
I think, therefore I am - Rene Descartes
Humans are aware. It's a bold assumption, but it's one that is important in determining our execution mode. However, the idea of having a state of consciousness is what allows us to silently judge people. It gives us an inner voice. It influences decisions. It's where emotions live, although it might not be where emotions are expressed.
Let's separate the expression of the conscious, or functions that deal with the external world as an
action. All actions belong to a singleton called
body. However, an action function may only be executed with a corresponding
thought functions. The singleton that contains all of the thought functions is called
Here is a sample of functions that
body contains; of course, they are overloaded to support different parameters to do the same thing:
//actions that belong to the body
body.raiseLeftFingerPhalenge2(double x, double y, double z) //may be very specific
body.performCPR(bool call911) // can combine lower level actions to do complex tasks
mind object contains all of the possible
thought functions. Although an
action function may run on its own, there a couple reasons as to why it is important to have it run within a
Mind is a higher level class that keeps track of context. It keeps track of analytic information for each function call and contains decisions functions this allows performing "deep-learning" on data. This will be useful to enhance decisions and thoughts for the future.
//the mind executes thought functions
var action = mind.generateActionForBody(body.getCurrentExternalTemperature()); //generate an action for the body based on stimuli
var emotion = mind.determineEmotionState(body.getAudioStream()) //decide an emotion with audio data and analyzing sounds and words
mind.execute(body.raiseLeftFingerPhalenge2(1,2,3)) //The mind can execute functions and know the current state
Understanding Mind Functions
body is a simple set of functions that do not affect the conscious state. However, they may be used to determine
Now that I elaborated on the idea of the types of functions that might drive a human, and their decision making ability, the next is program execution.
Whether life itself is a
dynamic program depends on your perception of the program. This is a common debate where life may either be pre-determined or self-driven.
If it is pre-determined, then there must have been a programmer that hard-coded each mind and response functions.
|Time itself is an ever-incrementing program counter. However, jump instructions do not take us to execute back in time, they instead allow us
Time is just the unit in which a program executes. It cannot be decremented, but functions may be repeated