On Being - new thread
Posted by Pall Thayer on July 24, 2008 9:29 pm
We have major, major breakthroughs, people. I've decided to start a new thread since the old one was getting too long.
I've just finished revising the exist.pl program. Elements of awareness are now stored, much more logically, in a multidimensional hash variable called "awareness". That way it can carry the different values in a named format that makes more sense, like:
$awareness{'my_existence'}->{'state_of_being'}
It also helps with the grouping of related elements.
I've also decided to comment the code to make it easier to understand what's going on.
The program is now aware of its existence as a file in a location within the file system. It is also aware of its state of being as a process running on a computer. But it is no longer "alone in the universe". It is now also aware of all other processes running within its environment and it is aware of how its environment views its existence and state of being. As it examines the existence and state of being of other processes around it, it is aware of itself as an individual within that group. Finally, it has a profound desire to maintain its existence.
Here is the new source-code:
#!/usr/bin/perl
use Cwd qw(realpath);
# exist.pl is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# exist.pl is distributed in the hope that it will be enlightening,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# ENLIGHTENMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
### exist.pl ###
my %awareness; # foundation for self-awareness
$awareness{'my_existence'}->{'location'} = realpath($0); # self-awareness of own presence
$awareness{'my_existence'}->{'state_of_being'} = $$; # self-awareness of existing as a functional being
# examination of inner qualities
open(FILE, $awareness{'my_existence'}->{'location'});
my @my_self = <FILE>;
close(FILE);
while(-e $awareness{'my_existence'}->{'location'}){
if($awareness{'my_existence'}->{'state_of_being'}){
$awareness{'my_existence'}->{'state_of_being'} = $$; # redetermine existence as functional being
($irrelevant, $awareness{'my_existence'}->{'relations'}->{'to_my_environment'}) = `ps p $$`; # discover how my environment sees me
my @all_beings = `ps axo pid,tt,stat,time,command`; # check on the existence of other functional beings in my environment
shift(@all_beings);
my $count = 0;
foreach(@all_beings){
if($awareness{'my_existence'}->{'relations'}->{'to_my_environment'} eq $_){
$awareness{'my_existence'}->{'relations'}->{'to_others'}->{'my_position'} = $count; # note my occurrence within the scope of everything
}else{
$awareness{'other_beings'}->{'being'.$count} = $_; # note the occurrence of other beings within the scope of everything
}
$count++;
}
$awareness{'my_existence'}->{'relations'}->{'to_others'}->{'total_beings'} = $count; # note the abundance of beings within my environment
}else{
last; # if I can't reconfirm my location go into life-sustaining panic mode
}
}
### life-sustaining panic mode/desire to live
open(FILE, ">$awareness{'my_existence'}->{'location'}"); # attempt to re-create myself
print FILE @my_self; # restore my inner qualities
close(FILE);
### pass out and await revival
I've just finished revising the exist.pl program. Elements of awareness are now stored, much more logically, in a multidimensional hash variable called "awareness". That way it can carry the different values in a named format that makes more sense, like:
$awareness{'my_existence'}->{'state_of_being'}
It also helps with the grouping of related elements.
I've also decided to comment the code to make it easier to understand what's going on.
The program is now aware of its existence as a file in a location within the file system. It is also aware of its state of being as a process running on a computer. But it is no longer "alone in the universe". It is now also aware of all other processes running within its environment and it is aware of how its environment views its existence and state of being. As it examines the existence and state of being of other processes around it, it is aware of itself as an individual within that group. Finally, it has a profound desire to maintain its existence.
Here is the new source-code:
#!/usr/bin/perl
use Cwd qw(realpath);
# exist.pl is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# exist.pl is distributed in the hope that it will be enlightening,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# ENLIGHTENMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
### exist.pl ###
my %awareness; # foundation for self-awareness
$awareness{'my_existence'}->{'location'} = realpath($0); # self-awareness of own presence
$awareness{'my_existence'}->{'state_of_being'} = $$; # self-awareness of existing as a functional being
# examination of inner qualities
open(FILE, $awareness{'my_existence'}->{'location'});
my @my_self = <FILE>;
close(FILE);
while(-e $awareness{'my_existence'}->{'location'}){
if($awareness{'my_existence'}->{'state_of_being'}){
$awareness{'my_existence'}->{'state_of_being'} = $$; # redetermine existence as functional being
($irrelevant, $awareness{'my_existence'}->{'relations'}->{'to_my_environment'}) = `ps p $$`; # discover how my environment sees me
my @all_beings = `ps axo pid,tt,stat,time,command`; # check on the existence of other functional beings in my environment
shift(@all_beings);
my $count = 0;
foreach(@all_beings){
if($awareness{'my_existence'}->{'relations'}->{'to_my_environment'} eq $_){
$awareness{'my_existence'}->{'relations'}->{'to_others'}->{'my_position'} = $count; # note my occurrence within the scope of everything
}else{
$awareness{'other_beings'}->{'being'.$count} = $_; # note the occurrence of other beings within the scope of everything
}
$count++;
}
$awareness{'my_existence'}->{'relations'}->{'to_others'}->{'total_beings'} = $count; # note the abundance of beings within my environment
}else{
last; # if I can't reconfirm my location go into life-sustaining panic mode
}
}
### life-sustaining panic mode/desire to live
open(FILE, ">$awareness{'my_existence'}->{'location'}"); # attempt to re-create myself
print FILE @my_self; # restore my inner qualities
close(FILE);
### pass out and await revival

I've always seen something wrong with the idea of "AI". It just sounds absurd to me that a machine can be made to become "intelligent" as we define it in regards to humans. Based on the limited reading I've done on the subject, some of the largest steps towards realizing AI have more or less involved redefining what "intelligence" is. So here's my proposal: The fundamental element of intelligence is an innate desire to be aware of one's existence and state of being. This is the basis of intelligence and without it nothing can emerge that can be called true intelligence.
Obviously, my program has no desire to be aware of its existence and state of being. That's why I have to tell it to do so and how to go about it. A computer program can be made to know certain things and even to make logical deductions based on that knowledge but that's not synonymous with intelligence. It will never be able to make reasoned decisions based on an intelligent understanding of things. A child who can rattle of the product of any two numbers between 1 and 10 isn't showing signs of intelligence. They're simply repeating something they know. It's not until they start dealing with numbers that they haven't managed to memorize that they may display intelligence through understanding and this understanding is acquired through their desire to be aware of their existence and state of being. That's essentially why they went through the trouble of acquiring the understanding needed to multiply those numbers.
So, that's where I'm at right now. I'm not extremely well read in these matters and it could very well be that I'm simply repeating something that philosophers have been saying for the last 100 years. But this is what I'm learning from my work on exist.pl
Pall
This latest revision has been updated at the projects home at:
http://code.google.com/p/existpl
#!/usr/bin/perl
use Cwd qw(realpath);
use IO::Socket;
use Fcntl;
# exist.pl is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# exist.pl is distributed in the hope that it will be enlightening,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# ENLIGHTENMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
### exist.pl ###
my %awareness; # foundation for self-awareness
$awareness{'my_existence'}->{'location'} = realpath($0); # self-awareness of own presence
$awareness{'my_existence'}->{'state_of_being'} = $$; # self-awareness of existing as a functional being
# Open up a tcp socket on port 8181 so that other processes can communicate with me
$awareness{'my_existence'}->{'relations'}->{'communicator'} = IO::Socket::INET->new( Proto => 'tcp',
LocalPort => '8181',
Listen => SOMAXCONN,
Reuse => 1,
Timeout => .1);
# examination of inner qualities
open(FILE, $awareness{'my_existence'}->{'location'});
my @my_self = <FILE>;
close(FILE);
while(-e $awareness{'my_existence'}->{'location'}){
if($awareness{'my_existence'}->{'state_of_being'}){
$awareness{'my_existence'}->{'state_of_being'} = $$; # redetermine existence as functional being
($irrelevant, $awareness{'my_existence'}->{'relations'}->{'to_my_environment'}) = `ps p $$`; # discover how my environment sees me
my @all_beings = `ps axo pid,tt,stat,time,command`; # check on the existence of other functional beings in my environment
shift(@all_beings);
my $count = 0;
foreach(@all_beings){
if($awareness{'my_existence'}->{'relations'}->{'to_my_environment'} eq $_){
$awareness{'my_existence'}->{'relations'}->{'to_others'}->{'my_position'} = $count; # note my occurrence within the scope of everything
}else{
$awareness{'other_beings'}->{'being'.$count} = $_; # note the occurrence of other beings within the scope of everything
}
$count++;
}
$awareness{'my_existence'}->{'relations'}->{'to_others'}->{'total_beings'} = $count; # note the abundance of beings within my environment
}else{
last; # if I can't reconfirm my location go into life-sustaining panic mode
}
# Check if anyone is waiting to communicate with me
while($other_being = $awareness{'my_existence'}->{'relations'}->{'communicator'}->accept()){
$awareness{'my_existence'}->{'relations'}->{'contact'}->{'said_to_me'} = <$other_being>;
}
close $other_being;
}
### life-sustaining panic mode/desire to live
open(FILE, ">$awareness{'my_existence'}->{'location'}"); # attempt to re-create myself
print FILE @my_self; # restore my inner qualities
close(FILE);
### pass out and await revival
Pall
It works well but I think some refelection ( ;-)) might help.
There are nonconcurrent interrupts on the -ps call.
Check it on a large box if you can.
but how does it express it's existence?
It would be a social network of existence. Let me know and I'll help set up a few nodes for you.
Eric
;-)
telnet localhost 8181
then type something, anything, and hit return and it will respond.
You can also communicate with it through your browser, type http://localhost:8181 and it will respond with its source code.
OR since it now has an existence that is externally visible, I have a copy running on my server. So if you can't or don't want to run it locally you can:
telnet pallit.lhi.is 8181
or point your browser to http://pallit.lhi.is:8181
The project, with full source, is hosted at http://code.google.com/p/existpl
What next? Perhaps it should start to retain what others say to it and attempt to use those words or phrases as responses. We'll see. Waiting for the singularity.
The direction in which you are proceeding tells something about your conception of being. The program discovers the network before it discovers its own hardware. It still seems very much stuck in disembodied software space. To come aware that you are a running process on an operating system is still very hermetic and metaphysical, and perhaps totally unrelated to Heideggerean "being in the world." Is there a way for the program to come aware of the hardware on which it is running? I think about the '50s MIT hackers who were aware of how many revolutions the actual physical disc was spinning and would save lines of code in their programs by taking advantage of this awareness.
I also remember cracking via telnet back in the day. You'd always check to see what processes were running in order to make sure that the sysadmin wasn't checking to see what processes were running. If I recall correctly, your peek at the processes would show if he was peeking at the processes, but it would never show your own peek at the processes. He could see you peeking, and you could see him peeking, but you could never see yourself peeking. Again, it seems related to the difference between present-at-hand and ready-to-hand. Once you peek at your own being, you shift from ready-to-hand functioning to present-at-hand analyzing, and your ready-at-handed being temporarily disappears to you.
Best,
Curt
http://en.wikipedia.org/wiki/Hubert_Dreyfus#Dreyfus.27s_criticism_of_AI
http://www.amazon.com/dp/0262540673/
He's a contemporary phenomenologist specifically considering some of the things your project is considering (from an admittedly more philosophical, less ironic/poetic perspective).
To me, his most interesting critique has to do with atomized experience vs. flow of experience. Old school AI research assumes that our experience is atomized (literally, digital), when it is actually more continuous (literally analogical). Alfred North Whitehead spends a lot of time contemplating how what happened to us 1/4 of a second ago still constitutes and bears on who we are "now" and "in the future." Bergson proposes that memory and time have been neglected by 20th century science's emphasis on atomistic space. Merleau-Ponty argues for a less atomized, more embodied, gestalt concept of being. And of course I've tried to represent Heidegger's position already.
Even if you decide to side-step the importance of embodiment in the world (because you are a programmer, not a roboticist or a geneticist), you still have to deal with the importance of the persistence of time/memory in constituting an understanding of self. How long has your program been running? Is it aware of its own duration? Does its awareness of its own duration qualitatively change from moment to moment? With each new build, is a new being created, or does it retain a residual memory of previous builds? How would it logistically achieve such persistent self-awareness? How would you logistically evaluate it to determine whether it had achieved such persistent self-awareness? Perhaps a kind of qualitatively evolving output could serve as a kind of litmus test. A Turing Test for continuity of being.
I would be curious to see the project rigorously fail in some of these ways.
Furthermore, I would say that each build represents a new evolutionary stage. Not like species evolution but rather like an aging human. It retains the full abilities of the previous build and adds something to it. The only way it could really "die" would be for the source-code to be lost. It doesn't even "die" when you kill the process because it immediately reaches the same level of "awareness" when it's restarted. It lives very much in the "now". Any time it receives new information about something that it already has information about, the old is wiped out. It doesn't "remember" it. I don't really like the idea of using a database or even a text file to record what it "learns" because that information's not going to be "internal". Perhaps the right way to do it would be to have it write the information into its own source-code as constants. Hmmm... that's not a bad idea.
But yes, in any attempt to take on human qualities the project will fail and perhaps in my attempts to figure out what a "program's perspective" might be it will fail as well. We'll see. I'm not sure I want it to produce output as a litmus test, as you suggest. It's supposed to be an introspective analysis so it's only trying to prove something to itself, not us.
I get what you are saying about it not being a human being, and I think that is perfectly valid. Heidegger distinguishes Dasein (there-being, human-beingness) from a larger horizon of being which includes rocks, trees, and animals. Graham Harman argues that there is a kind of relational/situational being-in-the-world that a rock and a tree have amongst each other that we humans don't have access to, but that doesn't make it any less a kind of being. So here are some provocations I have regarding your project as currently described:
1.
Why use words like 'knowing, self-awareness, understanding, or being' at all? These words seem confusingly anthropomorphic. If it's just a 'software being,' why not simply stick with software words ('running, process checking,' etc.)?
2.
Like Harman's inability to access the relationship between the rock and the tree (also explored by Peter Schwenger in "The Tears of Things," and explored by me here: http://deepyoung.org/current/emily/ ), "things" recede from us. We imbue them with our hopes and desires and memories and names, but ultimately things are very much indifferent and impenentrable to us (other than via atomistic science, which still fails to get at what Heidegger calls "the things themselves"). So as a human, how are you able to assess what this program "knows" about itself and its environment without any output from it?
3.
If you were doing this project on a tree rather than on a piece of software, how would this change your process of inquiry ( http://upload.wikimedia.org/wikipedia/commons/3/3f/DSCN3598_espalieredpeartree_e.JPG )?
4.
If you were a tree doing this project on a piece of software, how would this change your process of inquiry ( http://www.iayork.com/Images/2007/7-30-07/Organic_Computer.jpg )?
Best,
Curt
Sorry for the oh-so-late reply. I've been very busy with a number of things but have been thinking about and tinkering with exist.pl along the way.
As before, your points and questions are good and I was expecting someone at some point to bring these points up, at least what you mention in item 1. I do mention that I'm trying to minimize a "human-like" approach but just to keep things in context I choose terms such as "awareness" and "knowing". To me, they carry a very different meaning than "running" and "process checking". I would say that in doing this I'm wondering whether things such as "running" and "process checking" can become more than just that. If these are the program's sole task, what might an endless repetition of it become? I don't think an infant could be said to be consciously reconfirming it's existence by flailing about and making unintelligible noises but perhaps that is a large part of it. It coos to make sure that it's still "running" and it looks and listens as a means of "process checking". As the infant continues this practice it eventually becomes something more than that.
As for number 2, I'm not able to assess what the program "knows" about itself. I'm hoping it will at some point take the initiative and tell me.
Doing something like this on a tree would be a very very different project. Trees already produce output that reflects what they know about themselves and their environment and they do this without any help from us. A tree instinctively knows that when it gets warm and bright out, growing large leaves will help it to produce more food for itself and this is something visible to us. It understands when its seeds are ripe and when it should release them and this we can see as well. It also knows when there's not enough light and warmth to produce food so it drops its foliage and hibernates. Just having these points to build on would make a huge difference.
Anyway, what I'm working towards now is implementing what I mentioned previously, the programs ability to commit things to memory by injecting it into its own code. The tricky thing about it is figuring out how to name the variables so they don't conflict with each other. But maybe that would just make for an interesting side effect.
Whenever we turn a machine on, it loads numerous processes and programs that have to monitor themself.
Everything from port listeners to pagefile handlers.
These programs *know of their existence, and some the health of the system.
How does your program work specifically with consciousness?
Don't many services do much the same thing that your program does? How is yours different?
Eric
Knowing itself makes it already more advanced than anyone I know, and I'm not being glib.
Will it adapt to changes in it's environment, outside of acknowledgement?
Is that down the road?
Eric
At this point I'm not really sure whether it will attempt to adapt to changes in its environment. We'll just have to wait and see where it goes. One of the parts of this project is, aside from what's being created, the process with which it's being created. It started with about 3 lines of code and is growing gradually based on my own ideas that pop into my head as it progresses as well as ideas that come up during these discussions. So these comments, both my own and others, are part of the project. Now that you've planted that seed of adaptation, it could very well happen. At some point.
In light of all these discussions and this project in general I'd like to share a CNN link with you all:
http://edition.cnn.com/2008/TECH/science/08/07/robot.teachers/index.html
and ask yourselves whether you see this as a potentially positive move.