TODO

~passing arguments
~program flow control
~variables
better errors regarding programming
~make ValuePass a shared pointer
~add in single operators like += -= *= /=, These _not_ added in: -- ++
break, continue, not in there yet

~objects
~arrays <---- really need to do this
	need to make this save into database
~import
~classes
~fix functions to support classes and bindings
~database, need to still do for objects
	~need to remove limitation that objects need to be empty when inserted into database
	if an init function is added to classes, then classes could appear to have saved data by using objects as tempory forms
	Make classes unable to have additional fields just added like objects can
	Make classes savable into the database but only recored fields that are marked with Db, that way the problem of serializing functions will not become an issue

~C++ bindings <------ only working when it is statically linked, there is some problem with dlopen in that symbols are not being taking from the main program
modifying code


"unlimited" ram
auto parallization (thinking of making threading easy like in golang)
distrubited process

~thread support, thinking function like go that returns a value that blocks when read but returns when the function returns
~Also thinking that the variable system could easily support a queue message system, if made thread safe then this could provide useful to cross process messaging

Networking:
To make the system able to work over the network I need to transisition it to use a callback like system, so that data can be delayed
what will need to happen is that there is some even loop like system, and that it will be able to use callbacks to get values over network

	I am thinking that for the first version I could use threads, there is a yeild system, then there could be a relativetly simple even system used for waking up the threads when something happends, that should keep the design simpler


Switch the event system context switching to use the boost::context switching, as that should enable it to be more cross platform


Currently possibly limiting cross platform:
	The posix based context switching
	C++11 compiler (not going to be fixed, but expect over time support will get better on other platforms)
	How it find the location of the raw exe file to look for include files



1/1/2014
abstract away all of the base classes, eg should have a class for passing arguments to functions
also clean up the variable system, make it smarter as being able to take more values and automatically create a new value if needed
     eg:
	class ValuePass : boost::shared_ptr<ilang::Value> {
	public:
		template<typename T> ValuePass (T &t) :boost::shared_ptr<ilang::Value>(new ilang::Value(t)) {}
		ValuePass ...
	};


JIT engine using tinycc, possibly have some meta language so that it can easily generate code on the fly
need to get modifications working better first
how would this work with threading if the code was changing and it was compiled, where would it know to change the code if it was creating new code instead of modifying the syntax tree


3/15/2014
Latest:
keywork arguments
Change the type checking system to not use keyworks, and instead of some identifer with a class, eg: have a class with some validate method and then call it when preforming the type validation

The system needs to be cleaned up internally, since it is becoming difficult to work with.  The jit engine is not necessary in the sort term and might not be required since the theme should be mostly calling out to C++ functions that are doing the heavy lifting computationally, and then just stringing together the components.  Thinking that the system could use some unit tests are there are starting to get a number of interal components.  Then there needs to be cleaning relating to the abstracting of working with functions, classes and objects as the current interface is "leaking" all over the code base.

5/13/2014 (Refactor)
1) Functions need to be more abstracted.
	 * Abstract the calling mechanism
	 	 context of function created, this parameter, C++ vs ilang functions
	 * better support for passing arguments
	 	 this will allow for kwargs to be also passed
2) variables/scope overall
	 * make the variables hold the value themselves rather than being pointers
	 * the system will use more oop and no more boost::any
	 * this needs to have the support for there names and modifiers built in, since we should be relying on the parserNodes for that
3) Using make_ptr to make std::smart_ptr
4) There should be some common hash mapping representation.
	 * this should be used to back objects and classes


7/10/2014
Need to add in error checking with 1/2 way reasonable errors to the parser tree

7/16/2014
We should be able to have "algebric" types by adding functions together, eg if we write {|Int + String a|};  Then the `Int + String` will validate that it passes the check for being an Int or a String.

8/8/2014
Better error handling for parser errors

8/24/2014
Possibly change the syntax for class/objects to look more like the rest of the language with using = and ; instead of : and ,.  Then there could also be support for using something like loops as one would in a function.  eg:
object {
			 a = 1;
			 b = 5;
			 while(b < a) {
			      a += 1;
			 }
};

maybe some yield-ish support??
times(5) {

}
what is the use case for this that actually makes since, would it just allow people to implement their own object/class like systems and then object/classes could be implemented using the same methods

8/28/2014
Create some sort of proxy object concept, so that objects can be represented that are loaded on other machines or backed by something else, eg: db

8/29/2014
change to use berkeley db, when the system starts supporting distribuited, it will have units of code which will each be able to have their own dbs

8/31/2014
Assuming that support for using ones own {} with some function calling, then there could be some table like interface like:
DB("name") something = Database.table {
					 Database.name("column_name") Int Database.index random = null; // default value
					 Database.unique Database.autoinc another = null;
};

something.find(`random, 123);


thinking that the json loading/dumping of data is too specific of a use case, and there should be possibly some better way to dealing with the data