Sounds like you need continuous integration techniques more than anything else. 
 If you haven't already,for your next project assemble a Test Driven 
Development platform JUnit / NUnit etc. and develop test cases for each of your 
Abstract Data Types (or classes as they're called nowadays). 
Best of luck.
~PM
Date: Mon, 2 Dec 2013 09:46:38 -0500
Subject: Re: [agi] I guess I don't have AGI all figured out.
From: [email protected]
To: [email protected]

I didn't mean to be so sharply critical.  I was trying to say that if a 
programmer thinks an AGI program could start with a simple program and build 
itself then he should try to create something that actually had the power to 
learn how to build itself.  I have thought about this and it is not easy 
"simple" but simple examples are probably feasible.  If someone thinks that an 
AGI program can feasibly start out simple then try something and let us know 
how far you get it to go.
 I was using my C++ templates with data arrays.  So all the most common 
functions of putting data into the array, finding it, retrieving it, 
distributing the data (in the mundane sense of the term), creating an index 
over the distributed data and the implementation of accessing the index as the 
first step to searching for the data and coordinating one or two data accesses 
was what I encoded into the template form.  The moment I started working with 
coordinated data for the most elementary stages of the AI part where I needed 
three, four and more data arrays to be used in a coordinated way, the debugging 
problem turned into an impossible task.  Although the templates had been tested 
I hadn't tested the all the particular methods that the templates could be a 
part of and I wasn't able to follow all the debug paths into the templates 
because the programming debugger did not reveal the values or the types of data 
when it stepped through the templates.
 Case-Based Reasoning is a historical AI method.  You make them extensible by 
using a particular context-free language that allows you to program the 
computer to represent new cases.  Theoretically, contrary to Tintner's 
argument, it would be feasible to use CBR to discover and represent truly novel 
situations.  However, this theoretical argument is not easy if you haven't 
already been there and the tendency to rely on already proven methods means 
that it is pretty predictable that someone who tries Case-Based Reasoning is 
not going to figure this out.  I want my AGI program to be able to do some 
genuine learning using a trial and error method.  Just as I (believe that I) 
don't need to use predefined human-language syntax to get the program to 
acquire a rudimentary human language, I also (believe that I) don't need to use 
predefined cases to get the program to acquire cases where it could use 
case-based reasoning.
 Chomsky's hierarchy of grammar is based on computational methods.  Whenever we 
write a computer program we are using computational methods so we can say that 
a computer program is supplied with predefined grammars.  However, the point is 
that my program will have the potential to acquire new pieces of grammar.  
Similarly every program uses case-based reasoning in the form of conditional 
branches.  However, the goal I am striving for is to get the program to do some 
genuine learning on its own.  This means that it will have to use a trial and 
error approach to learn about new things.  So it will be able to pick up 
something that looks a lot like case based reasoning without my programming it 
directly into the program.  On the other hand, if I was successful then it 
might be argued that I had developed a new way of programming a computer 
through instruction.  This new way of programming would not produce programs 
the way we usually do because what the program could learn would be mediated by 
many other impressions that it formed from its IO data environment.  So while 
it might learn, for example, to build a case for discerning when I am trying to 
teach it something new, it might mediate an effective method for learning new 
things with other information that it had previously acquired that it might use 
to interpret the new information with something that it had already learned.  
Since interpreting a situation in terms of similar situations which it knew 
something about is the natural policy of artificial thought this should be 
something that occurs frequently. So its recognition that I am trying to teach 
it something new might be mediated and defeated by its recognition that what I 
was trying to teach seemed familiar in some way.
 Should I have answered no but I have studied case-based reasoning carefully 
and I was using templates to represent char strings and ID values that refer to 
collections of derived relations between the data objects and strings formed 
from ID references and functional operations designed to work with the ID 
references?


On Sun, Dec 1, 2013 at 11:32 AM, Piaget Modeler <[email protected]> 
wrote:




Have you tried any Case-Based Reasoning approaches?
If engineered correctly the cases can be human readable, yet 
extensible.Starting with simple cases and increasing complexity.

What data structures were your common templates attempting to embody? 
~PM
 




  
    
      
      AGI | Archives

 | Modify
 Your Subscription


      
    
  

                                          


-------------------------------------------
AGI
Archives: https://www.listbox.com/member/archive/303/=now
RSS Feed: https://www.listbox.com/member/archive/rss/303/21088071-f452e424
Modify Your Subscription: 
https://www.listbox.com/member/?member_id=21088071&id_secret=21088071-58d57657
Powered by Listbox: http://www.listbox.com

Reply via email to