Index: branches/FACT++_scripts_refactoring/explicit_changelog
===================================================================
--- branches/FACT++_scripts_refactoring/explicit_changelog	(revision 18239)
+++ branches/FACT++_scripts_refactoring/explicit_changelog	(revision 18262)
@@ -13,5 +13,5 @@
 As script works nicely, but somebody needs additional output, so a new variable is created in the top of Main.js:
 
-	var i_am_already_used_inside_an_included_script = some_value;
+    var i_am_already_used_inside_an_included_script = some_value;
 
 Further down the line, there is an include(), which alters the value of "i_am_already_used_inside_an_included_script", because it happened to use the same variable name.
@@ -24,5 +24,5 @@
 
 A) There are no scripts to be included, that have side-effects.
-	I.e. All scripts, which are included into the Main.js or any other main-like script, should only create new functions, or reference types (aka classes), but never call any function or instanciate new objects.
+    I.e. All scripts, which are included into the Main.js or any other main-like script, should only create new functions, or reference types (aka classes), but never call any function or instanciate new objects.
 
 B) Even better: Scripts, which are written, to be included into a main-like script, should simply create their own scope. If they have their own scope, of course they may create instances of new classes, or any other variable, which stays bound to the 
@@ -30,26 +30,26 @@
 
 Example:
-	# great_functions.js
-
-	var great_functions = {
-
-		scoped_variable1 : "foo",
-
-		great_function1 : function(parameter1){
-			console.out(parameter1);
-		},
-		
-		great_function2 :function(){
-			console.out(this.scoped_variable1);
-		},
-	};
+    # great_functions.js
+
+    var great_functions = {
+
+        scoped_variable1 : "foo",
+
+        great_function1 : function(parameter1){
+            console.out(parameter1);
+        },
+        
+        great_function2 :function(){
+            console.out(this.scoped_variable1);
+        },
+    };
 
 Use the functions from great_functions.js like:
 
-	include("great_functions.js");
-	great_functions.great_function1("foo");		// --> foo
-	great_functions.scoped_variable1 = "bar";
-	great_functions.great_function2();			// --> bar
-	
+    include("great_functions.js");
+    great_functions.great_function1("foo");     // --> foo
+    great_functions.scoped_variable1 = "bar";
+    great_functions.great_function2();          // --> bar
+    
 
 C) If one wants to create a lot of funtions, which should go into one single scope, like a library for example. I'd suggest to do it like this:
@@ -67,25 +67,25 @@
 Let new_lib.js create the scope and include all parts of the library inside new_lib.js:
 
-	# new_lib.js
-
-	var new_lib = {};
-	include("part1.js");
-	include("part2.js");
+    # new_lib.js
+
+    var new_lib = {};
+    include("part1.js");
+    include("part2.js");
 
 Then inside the parts of the library (names can be chosen arbitraryly of course.) attach the new functions or reference types to the namespace created in new_lib.js:
 
-	# par1.js
-
-	new_lib.a_function = function(){
-		// do something astonishing!
-	};
+    # par1.js
+
+    new_lib.a_function = function(){
+        // do something astonishing!
+    };
 
 
 Of course all this heavily relies on convention, and not to break the convention. But I think, it would work. In the main-like script, which wants to use a_function() just do:
 
-	# main_like.js
-
-	include("new_lib/new_lib.js");
-	new_lib.a_function();
+    # main_like.js
+
+    include("new_lib/new_lib.js");
+    new_lib.a_function();
 
 
@@ -105,25 +105,25 @@
 
 Okay so, this is more tricky. CheckUnderflow.js includes 4 more scripts.
-	CheckStates.js is included in CheckUnderflow.js *and* in Startup.js
+    CheckStates.js is included in CheckUnderflow.js *and* in Startup.js
 
 I think, it is time to invent something like include-guards. So, when a library is included another time, it checks, weather it was already included. Maybe like this:
 
-	# library.js
-	// this should be the global context, *if* include('library.js')
-	// was called in a global context. 
-	if (!('library' in this)){
-		var library = {
-			some_func : function(){
-
-			},
-			another_func : function(){
-
-			},
-		};
-	}
-	//maybe even: 
-	else{
-		console.out("multiple include of 'library.js' ");
-	}
+    # library.js
+    // this should be the global context, *if* include('library.js')
+    // was called in a global context. 
+    if (!('library' in this)){
+        var library = {
+            some_func : function(){
+
+            },
+            another_func : function(){
+
+            },
+        };
+    }
+    //maybe even: 
+    else{
+        console.out("multiple include of 'library.js' ");
+    }
 
 So I add, this new "include guard" to CheckFTU.js quickly.
@@ -181,2 +181,21 @@
 
 # ----------------------------------------------------------------------
+
+I just remembered, I should mention what I donÄt like about Hist1D.js and Hist2D.js
+(I mean apart from the fact, that this code would not be needed, 
+when we had used Python+PyDim instead of Javascript and a custom made JS interpreter.)
+I don't like that Hist1D() and Hist2D() *claim* to be a constructors, but in fact they are not.
+
+If you did:
+    var h = Hist1D.Hist1D(100, 0, 100);
+    console.out(h instanceof Hist1D);
+you would get a 'false'. 
+
+Also the fact, that one always has to call constructors with new, does not apply for Hist1D or Hist2D, why?
+In strict mode, not calling a constructor with new, will even cause an exception. But calling Hist1D() with or without new, does not make a difference at all.
+
+Should be changed.
+
+# ----------------------------------------------------------------------
+
+