PropertySheets
PropertyPanels
PropertyLists

Tweakables Concept

	A simple UI that is easily created to wrap a variable and make it possible to
	prototype by tweaking at runtime various variables

Properties Concept

	A variable that is wrapped in interfaces that makes it possible to integrate in
	to more complex software in more interesting way. For example being able to
	associcate a UI field with a property so that in two directions, they will reflect
	each other. In some systems the UI doesn't have a copy of the value of the property
	only a reference to the property

Name-Value Pairs

	Also known as a KVP, Key-Value Pair, it is very similar to a property, however it
	is either named or has an ID associated with the value so that it can be part of
	a set of values and referenced by the associative key or name.
	
Variants Concept

	In some programming languages, variables have a type which might be fixed, in others
	languages variables might not have a type at all. In strongly typed languages,
	the variable's type is fixed with a single type and unable to be changed. Variants
	add flexibility in these cases to wrap variables in a more complex type that allows
	this complex type to be cast to specific types which gives the ability to write
	generic code that can work with different types but using a common interface.

Serialization Concept

	Being able to reliably stream something from memory to I/O (eg disk or network) and
	being able to reverse this (de-serialize). Often just dumping memory to disk and
	then on a later execution restoring it from disk to memory won't work as there could
	be pointers. Serialization needs to do this but not involving pointers. It also needs
	to be aware of padding of data in memory and of endianess so that the serialized data
	can be de-serialized in other contexts.

Config/INI files

	Human readable text files containing list of name-value pairs, sometimes each one
	called a config-entry, and sometimes grouped or in nested groups. Name-value pairs
	for an applications settings might be serialized and de-serialized using a config file.

XML and XSLT Concept

	Can be used to serialize and de-serialize data. Used to exchange data between computers,
	but also XML is human readable for easier debugging. XSLT adds the ability to transform
	the XML from one form to another easily, making it easier to use XML in interoperation
	between systems. This is usually used when have long lists of data, such as the data
	a program operates on or processes.

Properties are basically variants which also implement the Observer pattern.

Tweakables are pretty similar to properties but include making UI for the properties.

Config files are lists of named properties.

Config files could be in XML.

Data files in XML could be transformed in to UI lists.



Plan
----

	What langauge bindings??
	Perhaps at first just C++, in source form, and with dual licensing
	A slick web-site
	
	Implement the Observer pattern
	Implement a variant type (internal)
	Implement a property type which derives observer and contains a named variant
	Implement property sets which can be nested
	Implement UI generation from property sets
	Implement serialization and de-serialization of property set templates and their values