From: pjb@informatimago.com   
      
   Shamim Khaliq  writes:   
      
   > i have no previous experience of AI but years of reading in child   
   > psychology. i am brought here because i have a theory of brain   
   > development which i hope to model to see if it works.   
   >   
   > i am choosing to program in Java because i am familiar with this   
   > language. if i allow my AI to dynamically change its own structure, is   
   > there any danger involved?   
      
   The danger in self modifying programs is the introduction of bugs, or   
   worse, of a "dead-lock".  Imaging surgically operating on your own   
   brain, yourself.  Since you need your brain to operate your brain, any   
   change that prevents you to correctly proceed to the next step will hang   
   you.   
      
   On the other hand, if you are not operating on the subsystems needed for   
   the surgical brain operation, then we can imagine you could operate a   
   change on your brain.   
      
   So if you can identify a core structure with the utilities needed to   
   change the rest of the program, you can envisage modifying dynamically   
   the other parts.   
      
   Alternatively, notice how a woman can create a new brain without   
   touching hers (making a baby).  Similarly, with versionning you can make   
   an AI evolve.  Ie. instead of changing the structure dynamically, you   
   engender a fork and modify it separately, and when you've checked that   
   it works correctly, you can replace the old AI by the new one.   
      
   If you don't change the core structure, you can also do the same with   
   the other parts of the AI, using some versionning.  This is what happens   
   with Lisp, when a function redefines another function, if the redefined   
   function is used, it still runs, while a new version is installed for   
   the new calls.  Eventually the old function may return, and lose all its   
   reference, and end being garbage collected.   
      
      
   These considerations are valid as well for modifying the low-level   
   software as for the higher levels.  For example, in an expert system,   
   you may have the same cases whether you want to change the expert system   
   engine, or you just change the rules (you need to have a consistent rule   
   set at all times).   
      
      
      
      
   The safest mode is to engender an improved "child", check it, and then   
   make it replace the parent.   
      
      
   The second safest mode is to modify only "peripheral" features, and   
   using versionning (at whatever granularity you want, from the function   
   up to the module).  It's better to have a good error handing system and   
   an explicit versionning management to be able to recover from errors in   
   the new version.   
      
      
   The other modes would be much harder to implement safely.   
      
      
      
   --   
   __Pascal Bourguignon__   
      
   [ comp.ai is moderated ... your article may take a while to appear. ]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)