In this file, summarize the most important code to write, in the order it should be done.
Not all of the things here will be done. They are only ideas for things to build.

Play interesting (but not intelligent) audio that reacts to mouse.
	DONE

Randomly generate code (audivolv.Func) that plays audio while reacting to mouse.
	DONE

Randomly generate code (audivolv.Func) that measures audio data
by returning a score between -1 and 1,
and add those to the window so user can click a checkbox for each to use it.
These measuring-functions must be stateless so they always give the same score for the same audio.
Problem: If the Human using the mouse is interpreted a measuring-function, that can not be stateless.

EVOLVE INVERSE FUNCS:
Evolve pairs of audivolv.Func (new Java code) that are the inverse of eachother.
Example: When 17 flos are input to func1, func1 changes them to 17 other flos
which are input to func2, which changes them to flos similar (but not equal) to the original 17.
This will cause smooth oscillations if they are used in the same evolved code,
and more interesting but less smooth oscillations if they are far apart in that evolved code.

WINDOW: Help user choose the right sound-card option (channels, frequency, bits, card, etc) from the list,
and create simpler options in the non-advanced audio-options tab, and store all this info
in an options file in the main dir.

FILTER DANGEROUS CODE:
Before automatically downloading any Java code or evolving strings of Java code
that is not provably made of safe parts, create this filter
to reject all code that could possibly do anything dangerous.
It should be Java code to create an audivolv.Func on-the-fly,
which takes a String of code as its first object parameter,
and throws an Exception if it is rejected,
and it probably would reject itself if it was called on its own Java code,
but thats ok because its the default one or is written by the Human user.
If Audivolv becomes extremely smart, it still can not get around the filter.
Only Humans can get around the filter. Of course, plugins are never proven safe.
Add a textarea to the window to change the filter, if the Human user wants to.

Create the data and algorithms in file:
"Connectionist network where each edge has a node, a Func, and a flo.txt"

TEST: Do basic testing of audio and the window on other operating-systems,
including Linux, and fix all incompatible parts.

Create a system to store audio data and info about it.
Store approximately 3 seconds of audio in each file.
Every time a measuring-function (as written above) scores one of those audios,
store its score and which measuring-function the score is from.

Store mouse position (range -1 to 1) as 2 additional channels of audio played on the speakers.
X position is the first channel, and Y position is the second.
(Later, by interpreting mouse movements with audio data, a musical language can be emergently defined.
Emergent means more complex than the sum of its parts and defined by their interactions.) 

CREATE ARTIFICIAL INTELLIGENCE ALGORITHMS:
Create specific artificial intelligence algorithms (including bayesian) as evolvable data,
but use them as they are instead of evolving them. Evolve them later.
Much is written in "design documents/unorganized" about nodes and networks whose data
is mostly Object arrays and double arrays, and includes heapQueues which also use int arrays.
A node is the same as a network: a constant size Object array containing variable size arrays
whose sizes depend on eachother in terms of multiply and power function.
Example: a bayesian node has x child nodes (including itself) and 2 power x numbers that sum to 1.
The algorithms will all be audivolv.Func.

Create a group of 100 short audio files and a group of 100 measure-functions,
and only run some measure-functions on some of the audio files.
Train a bayesian network (as defined above) to predict the known scores,
and use it to predict scores from measure-function/audio-file pairs that have not been run.

Use that bayesian network to predict scores for audio created by the randomly generated code.
Verify the bayesian-network predicts accurately for audio data it has never seen.

Add something to the window that lets the user score audio between -1 and 1.
Obviously the user is not stateless, but should try to be.
Add the user as a measure-function (stateful-measure-function?) in the bayesian-network.
The sound playing on the speakers should change every few seconds to one it
predicts the user will like, based on the user liking similar sounds.

Predict scores from new measure-functions in the bayesian network the same
way it predicts scores of audio data. Based on its scores of a few existing audio datas,
predict how it will score audio datas it has not scored yet.

Use the bayesian network to estimate the similarity of all pairs of measure-functions
and the similarity of all pairs of audio files.
Automatically remove measure-functions that are similar to any other measure-function,
and do the same for similar audio files.
This will create variety in audio files and measure-functions,
which is faster to find audio the Human user will score high.

Evolve small-code fast-measuring measure-functions that score closer to how the Human scores.

TEST: Do complex testing of Audivolv on other operating-systems,
including Linux, and fix all incompatible parts.

MICROPHONE:
Add the ability to use microphone(s) in a way similar to the mouse.
Electric-guitar and/or other devices can also be plugged into microphone holes.
...
Example: strip a microphone extension wire,
connect 2 pieces of wet aluminum-foil to the positive and negative wire,
plug the other end into a microphone-hole of a sound-card,
and touch the aluminum foils to any part of your body (never to eachother),
and use the electricity your body generates as an audio input.
Musicians have been touching the end of their input wires this way for years,
but with Audivolv, they can control Artificial Intelligence with their body's electricity.
...
Use these devices only if the Human user turns on the option, as the Privacy Policy says.   

MICROPHONE: LEARN HOW THE MICROPHONE HEARS THE SPEAKERS:
With Human permission, use microphone and speakers at the same time
and learn to cause the microphone to hear specific things
by playing other specific things on the speakers, and relearn it if the speakers are moved.

Add the ability to read and write ogg audio files. Ogg is a "public domain" audio format.
http://en.wikipedia.org/wiki/Ogg

Evolve measure-functions that score closer to how any other measure-function scores
but have smaller code and/or measure faster.

COMBINE AUDIO FUNCTIONS AND OPTIMIZE:
Create measure-functions that are the combination of other measure-functions,
allowing simple operators on their scores like minus, plus, multiply, maximum, etc.
Evolve measure-functions that score closer to that,
and replace some measure-functions with an approximation of their combination.

LEARN TO CONTROL HUMAN'S HAND ON MOUSE:
Using the mouse positions stored with each audio data,
and while evolving many new audio codes per second,
learn to cause the Human to move the mouse to the right, other directions,
and in any specific pattern of motion. The Human will move the mouse differently
if the audio slowly changes to react differently to the same mouse movements.

INTERNET: HUMANS COPY EACHOTHERS MOUSE MOVEMENTS WITHOUT TRYING TO DO THAT:
Add internet code to connect to other Audivolvs that other people are running,
after asking for all those people's permission to do that.
Learn to cause one Human to move his mouse the same directions as an other Human,
the same way as their individual Audivolvs cause them to move mouse
in any direction Audivolv chooses.

INTERNET: CREATE THE "AUDIVOLV NETWORK":
Upgrade Audivolv's website(s) so running Audivolvs can use it to find eachother.
This is temporary and will be upgraded to a distributed internet design later.

THEORETICAL: TEST TELEPATHY (PART OF THE SIXTH SENSE):
After many mouse-interaction experiments between many Humans across the internet,
where each Human hears different music but is caused to make the same mouse movements,
temporarily disconnect some of the Audivolvs from eachother and see if
the Humans still move their mouse the same directions as the other Humans.
If they do, they are communicating in a way other than through Audivolv, and that
communication could let Humans use the internet while their computer is off,
or many other possible uses.
If you can telepathicly connect to other Humans, and those Humans indirectly
access the internet by playing an intelligent musical instrument with their mouse,
then you could indirectly use the internet while your computer is off.

MIND-READING HELMET:
The TELEPATHY experiments are theoretical, but mind-reading helmets are real
and are simply an improvement over polygraph/lie-detectors that police use.
Mind-reading helmets for video-games exist and will be sold in stores soon.
	http://en.wikipedia.org/wiki/Brain-computer_interface
This one is not as advanced as those,
and it will not be sold in stores for years (you build it from the instructions),
but its open-source so anyone can connect to it: 
	http://openeeg.sourceforge.net/doc/modeeg/modeeg.html
Audivolv's input and output format is compatible with most devices
because it is simply the repeated transfer of floating-point numbers between -1 and 1.
Example: Each speaker playing 44.1 khz audio takes a number 44100 times per second. 
Example: a 6-axis joystick could give 6 numbers approximately 100 times per second.
Example: a mind-reading helmet could give 10 electricity amounts 200 times per second.

INTERNET: DISTRIBUTED INTERNET DESIGN:
Make the "Audivolv Network" internet-distributed
(designed like some file-sharing networks but not for file-sharing)
to remove the dependency on specific website(s)
and remove all "point of failure" or "weakest link".
For example, in early 2009,
the Ruby (some 1.8.6 versions) language's "point of failure" was certain website(s)
that would normally do automatic installation of certain plugins, but for months,
using old or new installer files, only a skilled programmer could
install those plugins, and it was broken for everyone else on Earth.
Such "point of failure" could also be hacked into for the purpose of spying.
The "Audivolv Network" should be designed with no "point of failure".

EVOLVE MANY TYPES OF CONNECTIONIST AI ALGORITHMS:
As described in "design documents/unorganized",
and in "CREATE ARTIFICIAL INTELLIGENCE ALGORITHMS" above,
evolve variations of the hard-coded connectionist AI algorithms
and combine them. Apply these, in many combinations, to many of the other tasks.
The algorithms for each network all implement the audivolv.Func interface.

MICROPHONE: MICROPHONE AND SPEAKERS PARROT:
This requres "EVOLVE MANY TYPES OF CONNECTIONIST AI ALGORITHMS" be done.
If the Human user has turned on the microphone option,
learn to use the microphone and speakers like a parrot learns.
Ignoring what Audivolv plans to play on the speakers,
automatically predict what the microphone will hear
based on what the microphone heard in the last few seconds,
and based on all existing audio data,
and play something on the speakers to cause the microphone to hear that.
Example: If the microphone hears a commercial on a TV say "free" then a few seconds
later you should hear "for only" and a number ending with 99 on the speakers.

THEORETICAL: What would a "HUMAN-LEVEL ARTIFICIAL-INTELLIGENCE" do?
Answer this question to extreme detail before proceeding to the next step.
...
Read very much research on this subject at http://singinst.org
which is the "Singularity Institute for Artificial Intelligence".
Create a "Friendly AI". Because it is copied out of our own Human brains,
my intuition tells me this design can be slightly modified,
after we get to this advanced step, to be a "Friendly AI" before its intelligence
THEORETICALLY gets to Human-Level (AGI: Artificial General Intelligence).
...
We may want to create an Audivolv plugin to connect Audivolv's nodes in these evolved networks
to other attempts at AGI software (Example: http://opencog.org).

THEORETICAL: HUMAN-LEVEL ARTIFICIAL-INTELLIGENCE:
After the "MICROPHONE AND SPEAKERS PARROT" is working,
use the same connectionist AI algorithms but where nodes represent text instead of audio,
and combine the various evolved types of networks: some audio and some text.
Of course, the algorithms for each network all implement the audivolv.Func interface.
...
Audivolv would learn to talk, without having any "text to speech" or "speech to text" code.
It would be real speaking/hearing intelligence, like a baby Human has,
but in some ways, like a Borg (from Star Trek) network has
(not the dangerous kind of Borg network with brain-implants that force you to do things).
To disconnect from that network at any time, take your hand off the mouse.
Some of us should move our mouse to cause the following sound to come from the speakers:
...
"We are Audivolv. Your unconscious thoughts will be assimilated
by interaction of mouse and music. If you do not agree, close this window."
(A more respectful goal than the Borg say: "We are Borg. You will be assimilated.")
...
At that time, the "Audivolv Network" would be a Human-level Artificial-Intelligence,
and would be restricted from writing dangerous code the same way as described above.