--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/core-javascript/core-javascript-work/tutorial.js	Mon Oct 31 11:07:46 2011 +0000
@@ -0,0 +1,201 @@
+var telltail = 'global';
+
+var TEST = function(title, code){
+    print( 'Testing: ' + title );
+    code();  
+};
+
+var assert = function(arg){
+    if(!arg){
+        ddt();
+    }  
+};
+
+'0' == 0 || ddt;
+0 == '' || ddt;
+'0' != '' || ddt;
+NaN != NaN || ddt;
+
+
+// start closures
+TEST('closures', function()
+{
+    // A factory for creating get-set pairs.
+    var get_set_factory = function(){
+
+        var value;
+        var get = function(){
+            return value;
+        };
+        var set = function(new_value){
+            value = new_value;            
+        };
+
+        return {
+            get: get,
+            set: set
+        };        
+    };
+
+    // Create and unpack two get-set pairs.
+    var tmp;
+    tmp= get_set_factory();
+    var get_a = tmp.get;
+    var set_a = tmp.set;
+
+    tmp= get_set_factory();
+    var get_b = tmp.get;
+    var set_b = tmp.set;
+
+    // Test that both pairs work.
+    set_a(12);
+    assert( get_a() === 12 );
+
+    set_b(13);
+    assert( get_b() === 13 );
+
+    // Test that each pair has its own value.
+    assert( get_a() === 12 );
+
+});
+// end closures
+
+
+// start return_this
+TEST('return_this', function()
+{
+    var return_this = function(){
+        return this;
+    };
+
+    var default_this = return_this();
+    assert( default_this.telltail === 'global' );
+    
+    var obj = {};
+    obj.return_this = return_this;
+    assert( obj.return_this === return_this );
+    
+    assert( obj.return_this() === obj );
+    assert( obj['return_this']() === obj );
+    
+    assert( return_this.call(obj) === obj );
+    assert( return_this.apply(obj) === obj );
+
+    assert( return_this.call(undefined).telltail === 'global' );
+    assert( return_this.apply(undefined).telltail === 'global' );
+
+});
+// end return_this
+
+
+// start transient-bind
+TEST('transient-bind', function()
+{
+    // Set up the test object.
+    var return_this = function(){
+        return this;
+    };
+    var obj = {
+        return_this : return_this
+    };
+
+    // Deferring method call changes the outcome.
+    var method_deferred = obj.return_this;
+    assert( method_deferred ===  obj.return_this );
+    assert( method_deferred() !==  obj.return_this() );
+
+    // The two outcomes, precisely stated.
+    assert( obj.return_this() === obj );
+    assert( method_deferred().telltail === 'global' );
+
+});
+// end transient-bind
+
+
+// start millers-device
+TEST('millers-device', function()
+{
+    var array = [];
+    var obj = {};
+    var fn = function(){};
+
+    assert( typeof array === 'object' );
+    assert( '' + obj === '[object Object]' );
+    
+    assert( obj.toString() === '[object Object]' );
+
+    var object_toString = obj.toString;
+
+    assert( object_toString.call(array) === '[object Array]' );
+    assert( object_toString.call(fn) === '[object Function]' );
+
+});
+// end millers-device
+
+
+// start return_arguments
+TEST('return_arguments', function()
+{
+    var return_arguments = function(){
+        return arguments;
+    };
+    
+    var my_arguments = return_arguments(0, 1);
+    
+    assert( my_arguments.length === 2 );
+    
+    assert( my_arguments[0]  === 0 );
+    assert( my_arguments[1]  === 1 );
+    
+    assert( '' + my_arguments === '[object Object]' );
+    assert( '' + [0, 1] === '0,1' );
+    
+    var array_slice = [].slice;
+    var my_arguments_fixed = array_slice.call( my_arguments );
+
+    assert( '' + my_arguments_fixed === '0,1');
+
+    var obj = {};
+    assert( obj.toString.call( my_arguments_fixed ) === '[object Array]' );
+
+});
+// end return_arguments
+
+
+// start new-operator
+TEST('new-operator', function()
+{
+    var this_in_Fn;
+
+    var Fn = function(){
+        this_in_Fn = this;
+    };
+
+    this_in_Fn = null;
+    var non_instance = Fn();
+    assert( non_instance === undefined );
+    assert( this_in_Fn.telltail === 'global');
+
+    this_in_Fn = null;
+    var instance = new Fn();
+    assert( instance === this_in_Fn );
+    assert( instance.telltail === undefined );
+
+    Fn.prototype.telltail = 'instance-of-Fn';
+    assert( instance.telltail === 'instance-of-Fn' );
+
+    Fn.prototype = {
+        telltail : 'prototype-is-changed'
+    };
+    var second_instance = new Fn();
+    assert( second_instance.telltail === 'prototype-is-changed' );
+
+    Fn.prototype = second_instance;
+    second_instance.i = 42;
+
+    var third_instance = new Fn();
+    assert( third_instance.telltail === 'prototype-is-changed' );
+    assert( third_instance.i === 42 );
+
+});
+// end new-operator