Movin’ On Out

Wow…it seems such a long time since I last wrote a post in the “My Life” category. Probably has some connection to the fact that I have little life to speak of, but I digress. It seems now that I’ve got something to speak of.

Tomorrow, I move into my new condo. It’s a nice place, and I’m quite excited. It’s a big step for me, finally — after 19 years — moving away from home. Of course, I’m nervous, but I’m nervous about everything, so what does it matter?

Ooh…I love how the nervous, happy jitters show through in my writing. It adds that hint of borderline insanity that makes writing fun.

Anyway, the long and the short of it is, I don’t know how long it’s going to be before I get the Internet connection hooked up at my new place, so I’ll probably be absent for a while. To both of my readers, I apologize for this.

Onward!

SymbolicAI — Update 1

I have now built a skeleton (well, perhaps the skeleton of a skeleton) of SymbolicAI’s symbol-manipulation code. Here is the program, Version 0.1:

/*
SymbolicAI V0.1 by Asymptote
August 2007

Fiddle about with this as much as you want, but I make no promises as to its stability
or usefulness. If you do fiddle with it anyway, you must leave this header intact.
*/

//The Symbol object. These objects will represent bits of code.
class Symbol
{
public:
int getIndex(); //returns the index of the symbol. The index is a way of identifying a symbol in a specific position.
int getCode(); //returns the code of the symbol. The symbol’s code identifies what kind of symbol it is. That is, what it does.
void setIndex(int newIndex); //changes the symbol’s index. This is akin to moving it.
private:
int myIndex;
int myCode;
};

int Symbol::getIndex()
{
return myIndex;
}

int Symbol::getCode()
{
return myCode;
}

void Symbol::setIndex(int newIndex)
{
myIndex = newIndex;
}
//End of the symbol object block.

//The Word object. These objects will represent groups of symbols that form functional procedures.
class Word
{
public:
int getIndex(); //The index of the word. See the comment on the Symbol object’s getIndex() method.
unsigned int getSize();
void setIndex(int newIndex);
void setSize(unsigned int wSize);
private:
int myIndex;
unsigned int mySize;
};

int Word::getIndex()
{
return myIndex;
}

void Word::setSize(unsigned int wSize)
{
mySize = wSize;
}

void Word::setIndex(int newIndex)
{
myIndex = newIndex;
}

unsigned int Word::getSize()
{
return mySize;
}
//End of the Word object block.

#include <iostream>
using namespace std;

int main ()
{
Symbol S1;
S1.setIndex(0);
cout << S1.getIndex();

Word W1;
W1.setIndex(1);
W1.setSize(5);
cout << endl;
cout << W1.getIndex() << “,” << W1.getSize();
return 0;
}

So far, all it does is allow the initialization of “Symbol” objects and “Word” objects, and the assignment of indexes and sizes to them. All the main() function does is initialize some test objects and print off their properties to the console.

Symbolic A.I.

The other day, I was bored, and so I started clicking on the StumbleUpon button on my Firefox toolbar (StumbleUpon is a neat little free plugin that sends you to random user-discovered webpages. Good if you’re bored and you want to discover something new, but also dangerously addictive). Somehow, I ran into a production journal for a program called PixelMachine, a raytracer programmed in C++, and put together over a weekend. It’s really quite impressive. That inspired me to start learning C++.

Today, boredom struck again. After clicking “Stumble” for a few hours, hoping to find something amusing, a thought occurred: why not start a similarly impressive project? What, though, could I possibly do? I’m still far too much of a C++ novice to program anything like that. I also didn’t want to do anything derivative. So I thought, why not a symbolic A.I. program?

I don’t know if “symbolic A.I.” is a pre-existing term, but even if it is, I’ll re-define it here (try and stop me! I dare ya’!). In my mind, symbolic A.I. is a sort of self-modifying computer program. The symbols involved represent little bits of computer code. This code, though, can modify and extend itself, in a very recursive, loopy sort of way. This is how I imagine the program’s learning process:

  1. The program is primed with a bit of code, perhaps a code for giving a reply to a yes/no question.
  2. The program is run. The program “mutates” and self-modifies at runtime.
  3. The program is run again, and user feedback (or computer-generated feedback) determines the fitness of the program’s new version
  4. The information from Step 3 is used to “push” the program in a certain way.
  5. Go back to Step 2.

Thus begins what will likely be a blundering saga: the SymbolicAI program-development journal! Not only will this track the development of SymbolicAI itself, but my growth as a C++ programmer. You, dear reader, will follow me as I thumb through references, hunt down tutorials on the Internet, and reverse-engineer and study other C++ programs.

And so it begins. I start with this:

#include <isotream>
using namespace std;
int main ()
{
return 0;
}

Who knows where I’ll end up? To work!