I’m certain that a lot of people will look at this article and ask why I’m writing it… After all, most people won’t become programmers, so this is useless information, right?
Well, I could ask why I am so interested in Jeff Lilly’s explanations of language and come to the same conclusion… I know how to use English well enough to be understood, so why am I interested in the whys and wherefores of language? The easy answer is because I’m curious about human thought, and the reasons behind language provide a direct look at how humans turn information into abstract objects.
I hope to return the favor by explaining some of the whys and wherefores of computer programming. Programs are a wholly human concept, an attempt to further abstract objects according to simple rules that non-conscious logic can interpret, organize, and present in ways that are again meaningful to conscious beings.
Unfortunately, I’m too close to the subject to see anything but the details. I see the variables and functions as specific implementations, rather than as a broad spectrum as I once saw them. Describing how programming sheds light on the human mind would be like describing the shape of a forest while sitting in the middle of it. In this analogy, if I were in the middle of a forest, I could describe how the trees interact with each other… Perhaps I could say that there are rules for how seeds spread depending on the terrain, but if I can’t see the terrain itself, then I wouldn’t be able to predict how far the forest could progress.
So, I’m turning around and asking for someone who has a different perspective to look at the terrain of computers while I describe the rules of specific programs. Somewhere in the middle, there will be a spark of insight that will explain how the human mind works and is able to come up with such a “child” as the computer. Hopefully, this insight could lead to consciousness within machines, or at least the illusion of consciousness, which is indistinguishable from consciousness itself.
So, I’ll start out by answering a question, then let my thoughts carry me from there.
Why do programs crash?
Well, the easy answer is that programs are written by people, and nobody is perfect.
Of course, that’s only one small part of the problem. Humans might not be perfect, but surely a mathematically exact machine should be able to pick up on these imperfections and correct them, right? Well, to a very large extent, computers do fix the mistakes of their human programmers.
Each programming language has compilers associated with them. Some compilers are free, others are only available when built into large development suites of software that sometimes cost thousands of dollars. Their jobs are all the same, though: Take a set of human readable instructions and turn them into machine readable instructions. During that process, the compiler does a series of sanity checks… Does it know if the variable X is an integer (a number without decimal places), if it can be a negative number, or to throw a huge wrench into the workings, is X a collection of letters that probably make up a human readable sentence?
Some compilers guess… Other compilers don’t care, and can change X from an integer into a floating point number (a number with decimal places) and into a string of human readable characters as the program assigns different values. Personally, I prefer the compilers that care a great deal, and will complain loudly if you don’t say exactly what type of value X should hold. The downside of this is that, when I started learning how to program, half of my time programming was spent tracking down confusing, ill-described errors that the compiler presented me. The upside is that if I accidentally assigned X a string of characters when it should be a non-negative integer, the compiler would tell me right away, instead of leaving it up to the users to find the bug.
For an example of why it would be bad… let’s say that I was working with a language that didn’t care about a variable’s type, such as the language PHP. If I assigned $X (PHP’s version of X) the value of “Mary had a little lamb”, then I tried to add 2 to it, what would I get? Well, in PHP, the value would turn into “Mary had a little lamb2″. That’s most probably not what I was looking for, right? Compilers that guess at what type of values we want to store in variables would let us write programs, but when the program actually runs, the program will get extremely confused, and either show extremely unexpected information (such as “Mary had a little lamd“) or it will crash entirely.
There are, of course, ways to avoid this problem. The problem of assigning an integer variable a string of letters usually pops up because the programmer thought that he was working with a different variable. Without going into the subject of scope (we haven’t even touched the topic of code blocks, yet, which is essential to understanding scope), just trust that two variables, appearing in two completely different parts of a program, can both be given the same name. (In fact, this little trick is essential in writing extremely large programs.) One popular (but “ugly”) way to avoid naming completely different variables the same thing is to put what type of value the variable should hold in the variable’s name. For instance, if we wanted to hold a non-negative integer value, we would name the variable uintX (U = Unsigned, or non-negative; int = integer, or a number that doesn’t have decimal places).
Another way to get around this mess is to be descriptive in what you are naming your variables. X should only be used when describing distance on a chart… how far to the left or right of the center of the chart that specific point is. (Similarly, Y means how far up or down the chart a point is, and when working in 3 dimensions, Z is the elevation above/below the chart.)
Another commonly used variable is I, which stands for iterator. If you want to do a specific task one hundred times, you would use I to keep track of how many times you did something. This is slightly dangerous, though, because you could have two iteration loops in the same area. For an example, let’s say that you want to have a 30 day trial where you did 100 push-ups each day. Us humans can clearly see that a day is very different from a single push-up repetition… but computers have to be explicitly told this. So, we start the loop, on the first day, we set I to hold a value of 1. We then start our push-ups, and set the variable I that we think is for the push-ups reps to 1… As we do a push-up, we count one higher… or in the computer, we add 1 to the value of I. After our variable reaches 100, we stop…
The next morning, we look at our variable I and notice that it is set at 100… Since that is higher than 30, we think we’re done with our 30 day trial, and don’t do any more push-ups.
An even more insidious problem is if we were doing fewer push-ups in our 30 day trial… say, only doing 20 each morning. Our plan is that at the end of the 30 days, we’ll add 5 more push-ups to our routine. Well, the first day, we set I for the number of days to 1, then set I for the number of push-ups to 1 as well. We do our twenty push-ups, and go on with our day. The next day, our variable is set at 20, so we think we’re on our twentieth day already… We add one to it, reset our number of push-ups to 1, do twenty, and go on our day again. The next day, our number of days is back to 20… so we repeat the previous day all over again… By the fortieth day, we’ll still think that we’re at day 20… By the hundredth day, we’ll still be at 20… In fact, we’ve entered into an infinite loop. (It’s too bad we can’t set our age that way, so that we’ll always be 20.)
(Programmers will notice the slight error in counting here… Yes, I should have started with 0, but I’m explaining, not demonstrating, and someone trying to write this type of code would figure their problem out soon enough.)
This brings us to the most common reason why bugs pop up in computer programs… Computers have absolutely no understanding of context. If you tell it to add 1 to the variable I, it will do just that, and it doesn’t have any concept of why it is adding 1, nor can it tell that it is re-enacting the movie Groundhog Day. Humans have a built-in understanding of context, which is why pronouns exist, such as “he,” “she,” “it,” etc. In fact, humans have such an innate understanding of context that we had to build in partial understanding of context into our programming languages just so that we could write large programs. The programming languages that emulate context are known as object oriented programming languages.
With an object oriented language, I can tell the computer to move “the” tasks items to the left in the ticker window… In fact, this line of code looks something like this:
foreach (BasicItem item in listDisplayedItems)
{
item.Move(-1);
}
This piece of code roughly translates into English as “Move all of the items in the bucket “listDisplayedItems” one pixel to the left.”
The line that starts with foreach says to, one by one, find every object that describes itself as a “BasicItem” and give it a temporary name, in this case, “item”. Just like our non-zero integer from above isn’t compatible with strings of letters, the object type BasicItem isn’t compatible with most other object types. It would be like having a basket of apples and oranges… We could have Granny Smith, Red Delicious, or any other type of apple, but the oranges wouldn’t be apples, even if they were Navel oranges. If we wanted to move apples from one basket to another, we have to pick up the apple (temporarily giving it our full attention, or in computer terms, giving it a temporary name) before we could move it. Once we set the apple down in the new basket, we can then ignore it, leaving our hands and attention free to pick up a new apple.
The curly braces, “{” and “}”, give our program a sense of context. Within the curly braces, the variable item refers to one of those BasicItem objects that are contained in our list bucket. As the programmer, I don’t care which BasicItem is currently named item, because each and every one will eventually have that name. It’s like standing in line at a bank… While you’re in line, you don’t have a name… Once you reach the end of the line, your name becomes “Next Please,” and it isn’t until you get to the window that your true name actually means anything.
(Jargon: In computers, there are lists, queues, and stacks… When it comes to lists, it doesn’t matter what order the objects are in… they’ll get named when they get named. A queue can be best recognized if you’re familiar with British English… For us Americans, it would be like a line at a bank, the first person in a line gets service first. I use queues extensively in TimeAgent; the first item on the list gets displayed on the screen first… As that item scrolls along the ticker, other items queue up behind, until there is room on the screen for them. They’re then dequeued from the waiting line, and get enqueued on the ticker itself… Once they reach the end of the ticker, they’re then dequeued from the ticker, and, if they’re not marked as ‘done,’ they’re re-enqueued on the waiting line. A stack can be seen as a stack of plates being washed… The first plate placed in the stack can’t be washed until every other plate above it is washed. The best use for stacks is tasks that require other tasks to be done first… For instance, if I’m doing my taxes, I need the proper forms, such as my W2s from each company. Before I get the W2s, I need to contact each company and update my address. Once I’ve contacted each company, I can remove that tasks from my stack, then I can receive the forms… After I have received the forms, I can remove that task and work on filling out the paperwork, and finally, back to the original task, I can file my taxes. The acronym for a queue is FIFO, or First In, First Out. For a stack, it is FILO, First In, Last Out.)
So, we’ve identified a lack of meaningful context as a primary difference between machine and human… yet humans have also added in a sense of context, even on a small scale, to help manage writing large volumes of code.
I suppose the next question is, how do humans recognize context? Computers need context to be explicitly stated… Humans, on the other hand, hold on to information that is out of context until either they can find the right context, or until they deem that information to be non-valuable, at which point they forget it. Almost all ah-ha experiences are at the point of putting information into the correct context.
As “purist” as I want to make things, I have to admit that a lot of human action is hard-wired into the brain. Hunger is wired in at birth, and the first reaction is to suckle. Our reward/punish feedback system is also hard-wired in, including pain and pleasure, as well as reactions to loud or comforting voices. Humans are also adept at re-programming themselves, known as learning, so that they don’t repeat actions that produce pain. (Admittedly, addiction shows that our reward/punish feedback system isn’t perfect, which gives more evidence that it is hardwired in.) A computer must be able to reprogram its actions, but must also have little control over what its own reward/punish system dictates.
That leads me to believe that a computer must have multiple layers of ‘consciousness.’ In fact, Maslow’s Hierarchy of Needs provides an excellent layering scheme… First, a computer needs to be able to function… that it, it must want a power supply. Programming desire would take quite a few trips up and down the scale from the basic hardware through to its “conscious” processor, but it could conceivably be done. Simply put in a ‘hunger’ variable, and every once in a while, say every hundred miliseconds, require the main processor to double check the battery’s charge and assign that value to the hunger variable.
Making it act on that variable, though, would be very difficult. Humans don’t act on their hunger when their blood glucose level reaches a specific point… we can delay eating by conscious action. If we simply said “If the battery is running at 10%, recharge” without letting the machine make a choice, it would be cheating. We can, however, assign higher values to the ‘hunger’ variable as the charge gets low, and eventually start shutting down non-essential systems in order to conserve energy (such as, in the case of an android, reduce the amount of power its balance system uses, or reduce the amount of ‘high level’ processing it is doing, which would probably affect its speech, or it would make certain types of decisions more slowly, but still enable it to decide to get ‘food.’) An android should be able to starve itself by continually making a decision to delay recharging… but it should also be very difficult for the android to make that decision… For example, if there is a case of life and death (for humans, hopefully), the android should continue to protect the people for as long as possible, until the point where its energy levels would make it incapable of performing tasks necessary to protect those lives. Being a doorstop, or holding an object, of course, would not require power, so if the android were able to protect lives while completely non-functional, it would remain even after its power was exhausted. (An additional circuit: power saving mode… completely shut off while it was waiting for a situation which requires inaction to change, although it would require a person coming by and pushing a button in order for the android to realize that the situation no longer required its presence.)
So, I’ve come to realize that humans have multiple processors… one of which is conscious. The lines between the processors don’t exist, but humans are able to do more than one thing at a time, most of which are unconscious, such as sitting upright. Our conscious mind sets sub-minds to a task, and those sub-minds perform that task until told to perform otherwise. Also, other sub-minds keep track of different parts of the body… Parts keep track of chemicals in the blood that tell us our ‘battery’ level, or how much blood glucose we have. Other parts anticipate pain or pleasure. When these sub-minds get information, they pass it on to the conscious mind, which is free to ignore the information if it feels that there is something else more important. The feeling sub-minds, however, are able to suspend the conscious mind, tell it to stop whatever other task may be at hand, and pay attention… for instance, if we hit our finger with a hammer, the pain brings all of our conscious attention to that finger.
To design a ‘conscious’ computer, we must create it in parts… We must first build a few sub-conscious computers with the tasks of keeping track of other parts… such as the input from keyboards, the state of data in a database, or whether other computers are having glitches. These first-layer machines shouldn’t have any judgment built into them… they simply monitor their environment. The next layer should perform a small layer of abstraction, one of the tasks of the spinal cord. For instance, if a doctor hits a specific part of our knees, we involuntarily kick even before we realize that the doctor made contact. These second layer computers should analyze and react with the most probable course of action… For instance, if a first layer computer goes offline, its second layer computer should double-check the connection, attempt to reconnect, and if that doesn’t work, attempt to reboot the offline computer. If that doesn’t work, then it should send a ‘pain’ signal up to the next level. The third level should be doing heavy abstracting… If someone is typing at a keyboard, or speaking into a microphone, or there are objects being viewed by a camera, these third layer computers should be taking the raw input and assigning them to ‘objects.’ For instance, a word typed into a keyboard should become an abstract concept of a word… not directly translatable into the series of letters, except by the third layer computers handling the translation. Third layer computers handling video should say that there is a “person” in front of the camera, and if possible, attempt to identify the person so that it can give a specific name, if known.
These third layer computers should also have direct access to the databases of objects… the memories, if you will. That way, if a specific sounds is recorded, it can be compared to other known sounds and identified, and the third layer should also be able to communicate with other third layer computers… so that if the sound of glass breaking is heard, the sound processing machines can ask the video processing machines what they’re seeing, so that it can tie the sounds and images together. If a camera sees glass breaking again, it can then send signals to ‘expect’ the sounds of glass breaking…
And finally, the highest order computers… I think, personally and completely arbitrarily, that there should be four fourth level computers… of which, one should be the conscious computer. By conscious, I mean only that it should have the ability to make changes to the other non-fourth level computers. For instance, if a third level computer reports that the word “hello” was typed into a keyboard, this one computer can respond by sending a signal back to that third level computer telling it to respond with its own greeting. The other three computers would be tasked with maintaining the database and testing the entirety of the system methodically…
The four fourth level computers would not be able to talk directly to each other… but they could talk by setting symbols in key areas accessible by the other three, such as within the layer three computers. For instance, one of the non-conscious computers could, if it so chose, have the record for the computer’s “name” be brought up by the sound processing computers, causing the conscious layer four computer to believe that it heard its name called. Yes, this would present a problem of schizophrenia if one of the three sub-conscious computers decided to play games… but I believe that this ability for the sub-conscious to replay events is what tells the conscious to re-check the relationships in the database, because there’s a new ‘ah ha’ moment to discover.
Perhaps sleep isn’t a bad thing at all for a conscious computer system to have… During that time, the system would go into a non-active mode, where the conscious computer would not be able to affect the other systems. During that time, the sub-conscious computers would replay the events that they were able to set up successful relationships for, bringing those relationships to the attention of the conscious computer. The point of making the system inactive is, if the system were ‘dreaming’ of a first-strike nuclear attack, it wouldn’t respond. This would happen entirely within the layer three and four systems, with limited communication with the layer one and two systems, only checking to see if they still function.
Of course, if there is activity from a layer one or two system, it would suspend the ‘dream’ and bring the entire system back under conscious control… so the video cameras would have to be shut off, just in case a curtain flutters in the wind as the air conditioner turns on.
Here’s my proposed Hierarchy of Android Needs:
- Human Safety
- Human Orders
- Personal functioning
- Personal safety
- Belonging
- Esteem
- Self Actualization
Yes, I included Asimov’s Three Laws of Robotics in Maslow’s Hierarchy of Needs.
This goes onto a stack of orders inside of what people call a Main Event Loop. That is, the Main Event Loop is a (mostly) infinite loop of instructions, allowing the computer to keep double-checking to see if certain conditions have changed.
This stack would put Self Actualization at number 1… If you remember, stacks are FILO, First In, Last Out. After Self Actualization, add Esteem, Belonging, Personal Safety, Personal Functioning, Human Orders, and finally Human Safety. The first step of the Main Event Loop would be to build a new stack of needs every time, then pull the top item off the the stack… in this case, it must check to make certain that no humans are in danger (or that its actions will not place a human in danger). After the first check, it must search through its list of orders… Has a human told it to do something that hasn’t been completed? Next, it must check its own personal immediate functionality… Is it going to run out of power before it can recharge? Are components in need of repair? After that, it checks to see if it can improve its future safety… Is it going to rain and cause a short-circuit? Next, it seeks to engage in conversation… share its knowledge and acquire new knowledge. After that, it seeks to increase its pleasure and joy ratings… and finally, it seeks to make the world a better place.
If any one of these needs require action, then the appropriate action is taken, and the entire list is rebuilt… That way, if there are multiple threats to humans, the android doesn’t go off and fulfill another need after fixing only one problem.
The problem with this, is that it is too structured for a conscious being. I don’t know anybody who goes around thinking to themselves “Am I dying? No. Am I sheltered? Yep. Do I belong to a group? Yep. Am I comfortable? Yep. Do I feel good about myself? Yep. How can I make the world a better place? [do something] Am I dying? No. Am I sheltered? …..” etc., ad-nauseum. Rather, I like the system in the game The Sims better, when the simulation is set so that the avatars work independently… They have a set of needs (hunger, bladder, fun, etc.,) that gain a ‘worse’ value over time. Once a need gets high enough, they perform an action necessary to reduce the urgency of the need, such as eat food, use the toilet, or play a game. This way, several different needs could be accumulating at any given time, and the avatar acts upon the most urgent. It seems that this most closely resembles the decision making of conscious beings… If I’m warm and comfortable, I’m more likely to play in the rain… especially if I know that I can take a hot bath when I go back inside. If I’m kind-of hungry, but really broke, then I’ll keep working through lunch, and throw an unappetizing meal in the microwave when I reach the point where I can’t work anymore.
Perhaps, in addition to the three sub-conscious processors maintaining the database, they would also keep track of a list of needs, and give each need a value, based on the first, more rigidly structured set of steps. The conscious processor would then look at the list of needs set up by the sub-conscious processors, and decide among the most urgent needs which one it could alleviate most efficiently. Instead of a loop with a stack of needs, we could give the most important needs higher upper values… for instance, if a human was in danger, we would give it a value of either 0 or 1,000 (will always happen), followed by giving the need to complete orders from humans a value of either 0 or 500 (will always happen, except in the case of danger to humans)… then “pain” would receive a value of either 0 or 100 (always happen, except when humans are in danger or under orders), followed by hunger and the various comfort needs ranging between 0 to 75, then the need to share ideas a value between 0 to 50, the need to build self-esteem a value between 0 to 25, followed by self-actualization at a constant 10 (it would never be ‘off’ because there’s always room to improve. So, if all other needs are between 0 and 9, there’s a good chance that it will work towards improving the world).
I don’t think that we could have robots without these needs… at least, not fully autonomous robots. If we didn’t include Asimov’s Three Laws of Robotics, then people would never trust the machines. If we didn’t include Maslow’s Hierarchy of Needs, then the robots would be wholly dependent upon us to improve them… we wouldn’t be able to set the robots out in the world and have them improve themselves and us. (Of course, we must clearly teach the robots that not including the 3 Laws in future versions of robots would directly violate the first law, putting humans in immediate danger…)
Do I want to work on such a project? Yes, absolutely.
I suppose the final question is, what am I missing? There is something about humanity which can’t be quantified… I don’t think that even this four layer system would approach consciousness, but I’m so close to the problem that I can’t see what answers there might be.
, each habit falls under the category of being responsible. The book