> 
> --- stevenav@att.net wrote:
> > 
> > 
> > > If Yggdrasil has 10 expanded dimensions then, how
> > does Skuld debug it if she isn't also 10
> dimensional?
> > The bugs would exist in 10 expanded dimensions and
> > Skuld wouldn't be able to see them any more than 
> > Keiichi can
> > > see Belldandy's true form. Do bugs constantly
> > regerate 3-D forms like Belldandy does? Why would 
> > they do that?
> > 
> > Well, this is just my opinion on this, but it seems
> > that bugs are generated 
> > BY Yggdrasil, (but created because of problems in
> > the system)
> 
> Interesting point. Are the bugs Skuld hits the problem
> itself (which would have to be the same dimensionality
> as Yggdrasil) or the resulting manifestation of the
> problem? It's like a code bug in a program. Is the bug
> the error in coding or is it the strange behavior
> generated by the error and reported by the user? 
> 
> I can see arguments for both sides, here. I need to go
> back and re-read the bug chapters. I have to say,
> though, that the idea of Skuld just going around
> fixing symptoms without fixing the problem itself
> doesn't appeal to me.
>   


Consider this then, let's examine my theory in a fully fleshed out manner. 

Potential Scenario
Yggdrasil is running along happily, processing wishes and whatnot, and 
suddenly an error is encountered. 
 

This error may have been created as a result of the Yggdrasilian equivilant 
of a mis-referenced memory page  call, or a stack dump
 
(using assembly language terminology since this is the most powerful computer 
programing language available, nothing is closer to true machine code than 
assembly)
 

Regardless, the error is created and the system software responds, it catches 
the error and ports the data regarding the information regarding the error 
and the last set of actions being taken that resulted in the bug. Pages of 
code regarding the error are processed to form a log, and suddenly 
 

POP!!

The bug is created. The bug itself busily hops around, it's furr, placement 
of eyes, # of whiskers, all contain information about where the error was 
created and what processes were being run at the time of the error. 
 
Further, since Yggdrasil itself must (arguably) be artificially intelligent 
(how else could it recognize a threat to something interfering in a wishes 
fulfillment?) the bug is processed into a form with rudimentary intelligence 
(animal level perhaps)
 

Now, this gets a little worrisome, because if Yggdrasil is itself AI, and if 
it itself is able to spawn off AI error packets (bugs), it follows that 
perhaps the Goddesses are merely representative AI's of Yggdrasil... think of 
them as daemons running on a unix system perhaps. 
 
Just a thought... 

Now back to the scenario. 

So the bug is spawned off, it has information encoded into it regarding the 
problem experienced, okay, peachy. 
 

Now what?

Well, along comes Skuld, debugger extraordinare. 
We see her wind up, and bop the bug, POP.. bug is gone. 

But what really happened?

Well, if it's a 10 or 11 dimension al representation, we've only seen the 
bearest hint of what really went on, much like how double clicking an icon in 
windows or on the mac OS is only the window dressing of what went on in the 
OS. 
 

In reality, Skuld aligned her other senses (some of which may only be 
Yggdrasil trouble shooting related, on the bug. 
 
She garnered a huge ammount of info on the cause of the problem by coming 
into physical contact with the bug (as we've seen it in 3 dimensions) and 
then the actual act of bopping it with her mallet was in reality a huge 
debugging (pardon the pun) algorythym. 
 

The bug was cross refed, analyzed, the code decompiled and reports regarding 
the cause of the error and potential coding fixes were processed and 
recompiled into an OS system patch. 
 

Great, dandy, so that bug is fixed. 

Now what?

Well, as any good programer will tell you, if you fix one bug in a program, 
the resulting fix will usually break something else somewhere else. 
 

So, that bug fix (the patch generated when Skuld bopped the bug) ends up 
causing some other routine to perhaps create an error if a certain series of 
eventualities transpire. 
 

So, basically the bonking of bugs is merely an object oriented programing 
language by which the goddesses garner information and process it to generate 
bug patches, which in reality , break other things sometimes. 
 


Just a (series) of thoughts. 

I'll hit the rest of your letter later. 

-Steve