„Your Inner Computer“ Series No. 7

Object Oriented Programming Principles in the Mind

© Heidrun Beer 2004

Original title: "Program Hierarchy"



We needed six chapters to discuss potential operating system problems in our inner computer, the mind, but one will be enough to discuss programming - although the world of program applications is so much bigger than the world of the operating system. Internet browsers, text editors, publishing programs, photo editors, company statistics, music and art programs, databases from every corner of life - any imaginable kind of intelligence and knowledge can be managed by a computer, once its operating system is up and running without distracting us by being unstable.

 The evolution of existence, growing out of the vast and unlimited - but unmanifested - potential of the Supreme Being, has striking parallels with the world of object oriented programming. If the rules and principles of object oriented programming were applied to human societies in present time, some amazing changes would happen and a lot of people would no longer have to suffer! Many of today’s social structures we could call a beta version - a program before it has been fully debugged (to debug - programmer term for the action of eliminating errors).


Program Objects

 In the world of object oriented programming, a program object is not a dry and boring collection of code lines, it is very active and nearly alive. It has a name, it occupies a space, it has a certain set of properties (attributes) and a collection of methods (activities). As an example, a program object “flower” would have properties like “color” and “smell”, and methods like “open”, “close”, or “wilt”.

If a programmer wanted to program a flower, he would first describe its properties and methods and then have the flower interact with other program objects. A simple little demo program (no actual programming language is used!) could look like this:

           Flower.Color = Yellow

     Flower.Smell = None

IF Sun.IsShining THEN




The flower object looks at a property of the sun object (“IsShining” can be true or false) and then either opens or closes. Haven’t we seen that many times in real life?

If we had to learn actual programming, we would of course need to study for a few months, but for our understanding of the mind’s programming - and, actually, of the inner workings of evolution - it is sufficient to understand four simple concepts.


1. Instances

A program object can be used more than once in a program. Each time it is used, another copy or clone of its definitions is created in the computer’s memory. These copies or clones are called an “instance”.

A program could create a cat and a mouse, both instances of the object “animal”, and then let the cat catch the mouse. Both instances have the same basic set of instructions (eat, sleep, move etc.), but during their interaction they become totally different characters.

Or a program could create two white rabbits, again both instances of the object “animal”. As one is female and the other one male, their interaction would be much friendlier than the interaction between the cat and the mouse...


2. Nesting

Nesting as a computer term has nothing to do with the nest of a bird or other animal - it is a shorter word for “multi-level interlocked system”. This is the second concept we need to understand if we want to have order in our inner computer, and no less in the global mind of humankind.

In life as well as in programming, not every object is entirely individual and independent. Beside many individuals, we also encounter combinations in various depths of grouping. A simple example would be the human body: atoms form molecules, which form cells, which form organs, which form a body. This is a nested system of modules.

Another well known nested system of modules would be individuals, who form families, which form societies, which form cultures, which form species, which form ecological systems (islands, continents), which form ecospheres (planet level). The bigger group contains smaller groups, and so on down in size, until we arrive at individual entities. It’s a little bit like a russian doll, where each doll contains the next smaller doll, only that in our system there can be more than one object in a “container”.

Note that on the level of a town, we already have a complex conglomerate of individuals, families and other entities. This complexity grows as we move up in nesting levels, but if a few simple rules are observed, being complex does not necessarily mean being chaotic!


3. Global and Local Settings

The third programming concept we need to understand - and which will enable us to either keep a complex system in good order, or to bring order into it if it has become chaotic - is the principle of global and local settings.

In this context, “global” means that a setting is valid for the whole program and “local” means that a setting is valid for only one object. Or, if we look at a higher nesting level, an object’s setting can be local within the program, but global to the “child” objects it contains.

For instance, the property “Position” is a setting which is local to each of the towns in a country. However, the same setting is global for the next lower nesting level, that of a family. All families in Hongkong are positioned in Asia. But they also have their own, personal position setting, or the mail man wouldn’t find them to bring them their letters!

Depending on the depth of nesting, we can have one, two, or a whole chain of nested objects, each of which has its own local property “position”. Here we have five: Earth.Europe.France.Paris.EiffelTower. The "Position" setting of each of these objects refines the "Position" setting of its parent.

To make it even more complex, there are also settings which are global for the whole program. For instance, all the nesting levels in the model above have the same setting for Day, Month and Year.


4. Inheriting

The last of our four key concepts - maybe you want to demonstrate them with paper clips on your desk or make a little drawing - is the concept of inheriting: Program objects can inherit properties and methods from each other, pretty much like Gregor Mendel’s peas inherited their parent’s flower color.

Let’s take the example of a simple head of cabbage. Cabbage is a cruciferous plant. This means, its flowers have four petals arranged in the form of a cross. We could say that the cabbage object has inherited its flower shape from its evolutionary parent, the cruciferous plant.  

Next, it adds its specific round ball shape and strong white roots to the definition - other cruciferous plants look different. The radish for instance has a small build and a round red root.

The cabbage has also “children”, or objects that inherit all of the cabbage properties, plus add some properties of their own. We know green, white and red cabbage plants. They have inherited the root shape and plant shape from “cabbage” and the flower shape from “cruciferous plant”. In programming language, it would look like this:

     WhiteCabbage.Color = “White”

     WhiteCabbage.PlantShape = Parent.PlantShape

     WhiteCabbage.RootShape = Parent.RootShape

     WhiteCabbage.FlowerShape = Parent.Parent.FlowerShape


The Root Object

Life starts with a very simple “object”, whose properties and methods are passed on to each and every later object.

Technically correct, the object’s name would be “Ultimate and unlimited, yet unmanifested potential”. Everyday human language has shortened this clumsy expression to “Supreme Being” or, even shorter, “God” - although this term is often confused with “ancient extraterrestrial astronaut” (a definition on which we will not elaborate in this article - read more here).

The root object of all life has a deeply fascinating definition. It consists of only two lines:

Define Object “Root”

     Method “Define”

     Method “Choose”                     

This is the situation of the Supreme Being before the “Big Bang”. At first, It is entirely unmanifested - the proverbial “void”. Then It executes Its method Define, maybe with a grandiose statement in biblical style like “Let there be light!” - and there is light! Actually, first It would probably say “Let there be space!”, and within the split second that the physicists assume the “Big Bang” has needed to create the beginnings of all existence, there would be a universe.


The Basic Difficulty

The basic difficulty we have on this planet, in programmer terms, is that some program objects execute their method choose in a way that makes it impossible for other objects to execute their own method choose. In human terms, some people use their freedom for acting in a way which destroys the freedom of others. A well trained programmer would recognize this as a bug (program error) and would improve his code so that such a corruption of the program’s integrity cannot happen anymore. He would program an inhibition into the code of the object “person”, which allows one person to use their freedom only if it doesn’t hurt another person’s freedeom.

If we are clever, we transplant the intelligence which turns metal boxes (computers) into useful tools right into the center of the greatest chaos we can find on Earth: into the places where people are being programmed. Especially where they are programmed with mental software that is destructive and turns them into enemies of each other!

Introducing the principles of object oriented programming into the education at nurseries, schools, training camps and universities might not be an instant cure for war and insanity on our planet, but it could help to create future generations where individuals respect each other’s power of choice, and therefore the totalitarian systems which create so much pain today would slowly go extinct, together with all their depleted uranium coated tank busting shells, their landmines, cruise missiles and other nice instruments that human nations currently use to enforce their own choices upon others.

And what’s even better, it would finally bring about true spirituality, first in our education systems and then in our societies: because these rules are based on the assumption that our power of choice is directly inherited from our very first spiritual parent, the “Supreme Being”, or God.

This is a message which we can hear from all great teachers of humankind if we just care to listen, be it Jesus Christ, the Dalai Lama or any other visionary. They say, we are “Children of God” - a spiritually aware computer programmer would say we are “Instances of the Supreme Being” - it’s all the same thing!



To further develop the analogy, the first object which inherits from Root is Individual. It is created by the execution of Root.Define. The definitions spawned by Root in order to create Individual look like this:

Define Object “Individual”

     Inherits from “Root”  // “Define” and “Choose”

     Property “IndividuationPoint” AS Space-Time

     Property “ReturnPoint” AS Space-Time

     Property “CurrentPosition” AS Space-Time 

     Method “ExpressSelf” // Flows out

     Method “ExperienceOthers” // Flows in

     Method “Conclude”             

Therefore, what we know about any existing individual, physical or spiritual, human or non-human, without asking any questions, is: 1. it is an instance of the Supreme Being, 2. it has inherited the Supreme Being’s power to define and to choose, 3. it emerged from the Supreme Being at a certain point in space and time, 4. it will return to the Supreme Being at a certain point in space and time, 5. it is currently located somewhere in space and time, 6. it has been “programmed” to express itself, to experience others, and to make conclusions from this interaction (it has been programmed to learn), and 7. as a direct result of 1-6, it has added its own new properties (attributes) and methods (capabilities or potential activities) to its basic definition: properties and methods which make it a specific and unique personality - the Define and Choose methods of the Supreme Being in full bloom.

In programmer terms, every object Individual would live in its own thread of the program “Existence” - an independent fibre although tightly woven into the tissue of the universe. Its length is determined by the times of its individuation from, and its return to the Supreme being (although some of it - the future part - is still undefined at present time), and its path through the tissue of reality is determined by the consecutive string of positions in space during its entire existence. For a soul or spiritual being, these moments of “birth” and “death” - not the birth and death of any physical body it may have inhabited or will inhabit - mark the end points of its “life”.



The second important object type derived from Root is Group:

Define Object “Group”

     Inherits from “Individual”

     // Included in the definitions of “Individual”,

     // the powers of “Root” are inherited as well!

     Collection “Members” as Object “Individual”

The minimum requirement for an individual to join any group would be a method Connect, based on its inherited method Choose. Note that the group can and will act as an individual, as it inherits all of an individual’s definitions. Who in the group has the responsibility to represent the group, and how the personal viewpoints of all members are combined to form the viewpoint of the group, is a matter of the group’s self-definition.

The two basic models would be a leader-follower structure (“Monarchy”) and a voting structure with an appointed speaker (“Democracy”). And here we have to start to debug the program code of present time’s group models, because for the program to become error-free, the individual’s rights to its own choices need to be restored.

At the very least the individual would have to have the freedom to leave a group (family, company, town, country or other) if s/he doesn’t agree with its principles. Then the group, even if it were really weird, could always argue that every individual in it is there as the result of a free decision.


Programming Error Examples

The following examples show social situations which violate the principles of object oriented programming. Their common denominator is that we as humankind would need to take collective responsibility for debugging these errors, if we want to leave cleanly programmed social structures to our children.

Country.FamilyForm = “Monogamy” is - in programmer terms - an illegal property setting. By making the property FamilyForm global to a whole country, the programmers override the power of choice which is inherited from the object Root by the objects Individual and Family. This property needs to be set on a local level by the object Family, or the method Choose which Family inherited from Root cannot be executed anymore without colliding with the global property setting for the whole country.

A country is on a much higher level of nesting than a family, and it would be bad programming if it were allowed to interfere with the choices made on the nesting levels below. An object treated that way would have two conflicting instructions: Choose (inherited from Root) and DoNotChoose (enforced by the fact that Country insists on setting that property on a global level). That serves well to drive a computer crazy, and no less the mind of a living being! There is little doubt that the many tragedies and crimes in the area of marriage and partnerships are fueled by this set of conflicting program instructions.

Overriding an object’s method Choose from a higher level of nesting is just a programming error. As simple as this sounds, in reality it can become - or better, it has become - awfully complex and very, very painful to very many individuals! To correct this programming error in all societies where it has been made, would mean to search millions, maybe billions of lines of program code for only one error which has been repeated countless times (we inherit the errors too...)

It would mean to discuss burkas with the the people of Afghanistan, freedom of speech with the people of China, homosexual marriage, polygamy and the school system - which enforces study hours on kids in a way that entirely wipes out their power of choice - with the European countries, the rules of presidential elections with the people of the USA (right now they don’t really reflect the counted votes 1:1), and many, many more issues.

Could that be done? The better question is: How good are we, collectively, as programmers of our reality? Can we face a task of so enormous proportions? Can we find, motivate, or even create the media channels to transport these ideas? An individual programmer’s pride would not allow him to deliver a software with so serious bugs. How about our collective pride as the programmers of humankind?



In the area of religion, the confusion is especially big. Country.Religion = “Islam” is again an illegal property setting, as Religion as a property belongs to the object definition of an individual, not to any object definition on a higher level of nesting. Again it overrides the individual’s power of choice to dictate this property setting to him - a very ironic situation, as the source of an invidual’s power of choice is exactly the same object Root, the ultimate parent, the Supreme Being, which every totalitarian religious leadership claims to represent!

Even a child is intelligent enough to understand that if individuals have inherited the power of choice from their divine parent, they will also execute this power of choice and arrive at different points of view. The only sin is to act against God, and God has created everybody as an “object instance” of himself, with an inherited personal and unlimited power of choice. How then can any religious leader act against an individual’s power of choice? Maybe they all need a little education in object oriented programming :-)


Self-determinism by layers of nesting

From the above we could derive a principle of “self-determinism by layers of nesting”. Any layer of nesting would then be self-determined on its own level and would have to insist on non-interference by any other layer of nesting, especially any higher higher layer of nesting.

We are used to this principle in the area of nations - diplomats consider it very bad manners to interfere with the inner structure or proceedings of another country. The same practice of non-interference would have to be developed on a cultural level, so that private decisions like the religion or the sexual orientation of an individual, or the number of wives or husbands someone can have (the family model) are no longer regulated by the state, or a church with political powers. Instead of national laws, we would then have individually formulated contracts.

There are countless situations in life, of bigger and smaller magnitudes, where our power of choice gets overwhelmed. Sometimes we have voluntarily given up a bit of it, as in agreeing with the working times of the company we want to give us a job, but often a law or a rule is really, really against our feelings. We need to look at legislation in a new unit of time and adjust it so that it becomes compatible with our spiritual nature as “instances” of the Supreme Being.



Executing the method Reader.Conclude - inherited, as we remember, from the object Individual -, we now find that democracy (the rule of majority) is not really the political system which best represents a program cleanly written by the rules of object oriented programming. The best model would be one where every individual, once it has fully defined itself, joins the family, group, town or country which resembles most closely its own combination of choices.

In the typical democracy, there is always a percentage of up to 49 percent of group members who don’t agree with the decisions made by the majority. It would be better to optimize this in such a way that the major groups of a country are allowed to implement different ideas - or maybe that countries in the whole world agree that they will accept the immigration of people who have an affinity to their political or economical system.

This could happen several times in a lifetime, so that people would be more mobile than today, as they keep migrating from one country to the next, until they have found their true home country - not the country where their physical body is born, but the country which best meets their self-defined inner needs.

Every now and then, a country would lose so many people by this process that it is more or less voted out of existence. For such a situation, special rules would have to be made, by which such a country’s land and resources are distributed between its neighbours in order to make space for the additional people they have absorbed in the years before. We get an idea of this if we look at the mass migration which currently happens between Mexico and the USA.



If we want to debug the errors in the social systems in which we have grown up, we need to stay aware of the levels of nesting. We can only change things within our local area of reach, or we would make the same mistake we are trying to correct: we would override other people’s power of choice.

We can always debug errors directly on the level of Individual, and if we have found a good partner, we can most likely debug errors directly on the level of Family - if there are any errors left. On higher levels of nesting, or in other groups on the same level of nesting, we can only create an indirect influence by executing the method ExpressSelf in books, articles, films and other media, in the hope to stimulate the members of these groups to use their methods ExperienceOthers and Conclude for a re-evaluation of their own situation as a result of our stimulation.

Of course we could speculate whether the Supreme Being has the capability of repairing the whole hierarchy of derived objects, simply by changing some of Its own code at the level of Root. If It did that, then every individual in the universe could inherit the code changes together with the original code, and all of reality could change in one instant (keep in mind that the Supreme Being lives outside of time!)

We find an example for such a solution on the nesting level of cells in most organisms: they have a code which would read something like

IF Cell.ErrorCount > DefinedLimit THEN


This principle is called “programmed cell suicide”. As long as it works, a body stays healthy, because all faulty cells which result from failed cell divisions destroy themselves before they can grow into something dangerous like a cancer. If it were also implemented in human beings, anybody who keeps causing trouble to others by making too many mistakes would finally self-destroy.

As the Supreme Being’s potential is unlimited, It could probably program such a method into our minds (or has it done so already?) - but it seems that It still trusts Its many children enough to allow each of them their own route of learning and their own decisions about how and when to correct any programming errors within their area of influence.


 „Your Inner Computer“ Series No. 6: Control Panel  --  „Your Inner Computer“ Series No. 8: Networking



Are you interested in our Reality Revision Program, based on a worldwide mental training exercise? Click here and make a difference!


 - or read more at the start of our  

Hit Counter

This page last changed on: 30. Mar 13