An Exploration of Non-linear Dynamic Systems (NLDS) and XML

["Roger L. Costello" <costello@mitre.org>]

Len Bullard wrote:

> I suggest starting a project that explores NLDS  
> and XML plus provides code examples.  This could   
> be most useful for an as yet unspoken number of 
> other efforts.
>
> The primary goals of the project include:
>
> 1.  Exploring non-linear dynamics through the 
> application of XML and XML tools.
>
> 2.  Create and demonstrate the application of 
> these tools to real world problems.
> 
> 3. Demonstrate programs which compete and 
> cooperate.

This is a great idea!  I think that an exploration
of this will open up tremendous insights into data,
XML, and systems.  Plus, it will open up (at least for me)
a whole new and exciting way to think about 
systems and programming. Let's do it!

I'll take a stab at getting things started.  First, I will 
offer my definition of a "non-linear dynamic system".

A non-linear dynamic system is one that changes
in a seemingly random way.  For example, the time
taken to process each person in line at a bank
teller is very random - some people will have
quick transactions and will be processed in short
time, other people will have lengthy transactions
and will take longer.  Thus, the system (the bank
queue) is an example of a non-linear system.  Also, it
is "dynamic" because the collection of people in line is 
continually changing.  So, the bank queue is an
example of a non-linear dynamic system.

[Is this an accurate/reasonable definition?]

Question: is feedback a mandatory feature of 
non-linear systems?

I think that the next thing to do is to characterize
from a programmer's perspective the approach that 
one takes when dealing with non-linear dynamic
systems, i.e., the NLDS-mentality. Len provides
some initial insights into this:

> A good NLDS program does not choreograph because 
> that makes the process a fixed form.  It orchestrates:  
> defines roles, rules of roles, and assigns instrumentation.  
> Then it is an intelligent performance and this can be tuned 
> to inhibit or evoke non-linear behaviors.

This needs to be expanded upon with some concrete examples.

I am eager to change my brain to the programming style 
that is required with non-linear systems.  I am so used to 
"controlling everything" in a program.  I think that in
a non-linear program one needs to "let go" of the control
and let the program evolve on its own.  I am eager to 
learn this new style (and change my brain)!

What's next?  How can you participate? I can think of 
four things:

1. Can you suggest some interesting examples which would
require non-linearity, and would use XML?

2. Can you suggest how XML may tie in well with non-linear
dynamic systems?

3. Can you expand upon Len's characterization of non-linear
programs, i.e., the NLDS-approach to programming?

4. Can you enumerate the potential benefits of a NLDS-approach 
to programming and XML?

As we explore this exciting topic I will attempt to keep
a running summary of things.  Thanks!  /Roger