Index: doc/next-tutorial/next-tutorial.html
===================================================================
diff -u -r26480a59b14cf250904da0cdc7d895f21b0ed5fd -rc2374366bcb47c70ebd33cb16c8152eba783987f
--- doc/next-tutorial/next-tutorial.html	(.../next-tutorial.html)	(revision 26480a59b14cf250904da0cdc7d895f21b0ed5fd)
+++ doc/next-tutorial/next-tutorial.html	(.../next-tutorial.html)	(revision c2374366bcb47c70ebd33cb16c8152eba783987f)
@@ -3,7 +3,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8" />
-<meta name="generator" content="AsciiDoc 8.6.7" />
+<meta name="generator" content="AsciiDoc 8.6.8" />
 <title>Tutorial for the Next Scripting Language</title>
 <style type="text/css">
 /* Shared CSS for AsciiDoc xhtml11 and html5 backends */
@@ -87,11 +87,15 @@
 ul > li     { color: #aaa; }
 ul > li > * { color: black; }
 
-pre {
+.monospaced, code, pre {
+  font-family: "Courier New", Courier, monospace;
+  font-size: inherit;
+  color: navy;
   padding: 0;
   margin: 0;
 }
 
+
 #author {
   color: #527bbd;
   font-weight: bold;
@@ -415,12 +419,6 @@
  *
  * */
 
-tt {
-  font-family: "Courier New", Courier, monospace;
-  font-size: inherit;
-  color: navy;
-}
-
 div.tableblock {
   margin-top: 1.0em;
   margin-bottom: 1.5em;
@@ -454,12 +452,6 @@
  *
  * */
 
-.monospaced {
-  font-family: "Courier New", Courier, monospace;
-  font-size: inherit;
-  color: navy;
-}
-
 table.tableblock {
   margin-top: 1.0em;
   margin-bottom: 1.5em;
@@ -539,6 +531,8 @@
 @media print {
   body.manpage div#toc { display: none; }
 }
+
+
 </style>
 <script type="text/javascript">
 /*<![CDATA[*/
@@ -739,8 +733,8 @@
 <div id="header">
 <h1>Tutorial for the Next Scripting Language</h1>
 <span id="author">Gustaf Neumann &lt;neumann@wu-wien.ac.at&gt;, Stefan Sobernig &lt;stefan.sobernig@wu.ac.at&gt;</span><br />
-<span id="revnumber">version 2.1,</span>
-<span id="revdate">March 2011</span>
+<span id="revnumber">version 2.0b5,</span>
+<span id="revdate">June 2013</span>
 <br /><span id="revremark">Written for the Initial Release of the Next Scripting Framework.</span>
 <div id="toc">
   <div id="toctitle">Table of Contents</div>
@@ -778,9 +772,9 @@
 the universal method combinator "next", which was introduced in XOTcl.
 The combinator "next" serves as a single instrument for method
 combination with filters, per-object and transitive per-class mixin
-classes, per-object methods and multiple inheritance.</p></div>
+classes, object methods and multiple inheritance.</p></div>
 <div class="paragraph"><p>The definition of NX is fully scripted (e.g.  defined in
-<tt>nx.tcl</tt>). The Next Scripting Framework is shipped with three language
+<code>nx.tcl</code>). The Next Scripting Framework is shipped with three language
 definitions, containing NX and XOTcl 2. Most of the existing XOTcl 1
 programs can be used without modification in the Next Scripting
 Framework by using XOTcl 2. The Next Scripting Framework requires Tcl
@@ -828,7 +822,7 @@
 examples. In later sections we introduce the more advanced concepts of
 the language. Conceptually, most of the addressed concepts are very
 similar to XOTcl. Concerning the differences between NX and XOTcl,
-please refer to the "Migration Guide for the Next Scripting Language".</p></div>
+please refer to the <em>Migration Guide for the Next Scripting Language</em>.</p></div>
 </div>
 </div>
 <div class="sect1">
@@ -837,19 +831,19 @@
 <div class="paragraph"><p>A classical programming example is the implementation of a stack, which
 is most likely familiar to many readers from many introductory
 programming courses. A stack is a last-in first-out data structure
-which is manipulated via operations like <tt>push</tt> (add something to the
-stack) and <tt>pop</tt> remove an entry from the stack. These operations are
+which is manipulated via operations like <code>push</code> (add something to the
+stack) and <code>pop</code> remove an entry from the stack. These operations are
 called <em>methods</em> in the context of object oriented programming
 systems. Primary goals of object orientation are encapsulation and
 abstraction. Therefore, we define a common unit (a class) that defines
 and encapsulates the behavior of a stack and provides methods to a user
 of the data structure that abstract from the actual implementation.</p></div>
 <div class="sect2">
 <h3 id="_define_a_class_stack">2.1. Define a Class "Stack"</h3>
-<div class="paragraph"><p>In our first example, we define a class named <tt>Stack</tt> with the methods
-<tt>push</tt> and <tt>pop</tt>. When an instance of the stack is created (e.g. a
-concrete stack <tt>s1</tt>) the stack will contain an instance variable named
-<tt>things</tt>, initialized with the an empty list.</p></div>
+<div class="paragraph"><p>In our first example, we define a class named <code>Stack</code> with the methods
+<code>push</code> and <code>pop</code>. When an instance of the stack is created (e.g. a
+concrete stack <code>s1</code>) the stack will contain an instance variable named
+<code>things</code>, initialized with the an empty list.</p></div>
 <div class="paragraph" id="xmp-class-stack"><div class="title">Listing 2: Class Stack</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -900,48 +894,48 @@
       <span class='nx-keyword'>return</span> <span class='nx-variable'>$top</span>
    }
 }</pre></td></tr></table></div></div>
-<div class="paragraph"><p>Typically, classes are defined in NX via <tt>nx::Class create</tt>, followed
-by the name of the new class (here: <tt>Stack</tt>). The definition of the
+<div class="paragraph"><p>Typically, classes are defined in NX via <code>nx::Class create</code>, followed
+by the name of the new class (here: <code>Stack</code>). The definition of the
 stack placed between curly braces and contains here just the method
-definitions. Methods of the class are defined via <tt>:method</tt> followed
+definitions. Methods of the class are defined via <code>:method</code> followed
 by the name of the method, an argument list and the body of the
 method, consisting of Tcl and NX statements.</p></div>
-<div class="paragraph"><p>When an instance of <tt>Stack</tt> is created, it will contain an instance
-variable named <tt>things</tt>. If several <tt>Stack</tt> instances are created,
+<div class="paragraph"><p>When an instance of <code>Stack</code> is created, it will contain an instance
+variable named <code>things</code>. If several <code>Stack</code> instances are created,
 each of the instances will have their own (same-named but different)
-instance variable. The instance variable <tt>things</tt> is used in our
+instance variable. The instance variable <code>things</code> is used in our
 example as a list for the internal representation of the stack. We
 define in a next step the methods to access and modify this list
 structure. A user of the stack using the provided methods does not
 have to have any knowledge about the name or the structure of the
-internal representation (the instance variable <tt>things</tt>).</p></div>
-<div class="paragraph"><p>The method <tt>push</tt> receives an argument <tt>thing</tt> which should be placed
+internal representation (the instance variable <code>things</code>).</p></div>
+<div class="paragraph"><p>The method <code>push</code> receives an argument <code>thing</code> which should be placed
 on the stack. Note that we do not have to specify the type of the
 element on the stack, so we can push strings as well as numbers or
 other kind of things. When an element is pushed, we add this element
-as the first element to the list <tt>things</tt>. We insert the element using
-the Tcl command <tt>linsert</tt> which receives the list as first element,
+as the first element to the list <code>things</code>. We insert the element using
+the Tcl command <code>linsert</code> which receives the list as first element,
 the position where the element should be added as second and the new
 element as third argument. To access the value of the instance
 variable we use Tcl&#8217;s dollar operator followed by the name. The
-names of instance variables are preceded with a colon <tt>:</tt>. Since the
+names of instance variables are preceded with a colon <code>:</code>. Since the
 name contains a non-plain character, Tcl requires us to put braces
-around the name. The command <tt>linsert</tt> and its arguments are placed
-between square brackets. This means that the function <tt>linsert</tt> is called and
+around the name. The command <code>linsert</code> and its arguments are placed
+between square brackets. This means that the function <code>linsert</code> is called and
 a new list is returned, where the new element is inserted at the first
-position (index 0) in the list <tt>things</tt>. The result of the <tt>linsert</tt>
-function is assigned again to the instance variable <tt>things</tt>, which is
-updated this way.  Finally the method <tt>push</tt> returns the pushed thing
-using the <tt>return</tt> statement.</p></div>
-<div class="paragraph"><p>The method <tt>pop</tt> returns the most recently stacked element and removes
+position (index 0) in the list <code>things</code>. The result of the <code>linsert</code>
+function is assigned again to the instance variable <code>things</code>, which is
+updated this way.  Finally the method <code>push</code> returns the pushed thing
+using the <code>return</code> statement.</p></div>
+<div class="paragraph"><p>The method <code>pop</code> returns the most recently stacked element and removes
 it from the stack. Therefore, it takes the first element from the list
-(using the Tcl command <tt>lindex</tt>), assigns it to the method-scoped
-variable <tt>top</tt>, removes the element from the instance variable
-<tt>things</tt> (by using the Tcl command <tt>lrange</tt>) and returns the value
-popped element <tt>top</tt>.</p></div>
+(using the Tcl command <code>lindex</code>), assigns it to the method-scoped
+variable <code>top</code>, removes the element from the instance variable
+<code>things</code> (by using the Tcl command <code>lrange</code>) and returns the value
+popped element <code>top</code>.</p></div>
 <div class="paragraph"><p>This finishes our first implementation of the stack, more enhanced
-versions will follow. Note that the methods <tt>push</tt> and <tt>pop</tt> are
-defined as <tt>public</tt>; this means that these methods can be
+versions will follow. Note that the methods <code>push</code> and <code>pop</code> are
+defined as <code>public</code>; this means that these methods can be
 used from all other objects in the system. Therefore, these methods
 provide an interface to the stack implementation.</p></div>
 <div class="paragraph" id="xmp-using-stack"><div class="title">Listing 3: Using the Stack</div><p></p></div>
@@ -994,24 +988,24 @@
 s1 <span class='nx-keyword'>destroy</span></pre></td></tr></table></div></div>
 <div class="paragraph"><p>Now we want to use the stack. The code snippet in <a href="#xmp-using-stack">Listing 3</a> shows how to use the class Stack in a script.
 Since NX is based on Tcl, the script will be called with the Tcl shell
-<tt>tclsh</tt>. In the Tcl shell we have to <tt>require package nx</tt> to use the
+<code>tclsh</code>. In the Tcl shell we have to <code>require package nx</code> to use the
 Next Scripting Framework and NX. The next lines contain the definition
 of the stack as presented before. Of course, it is as well possible to
 make the definition of the stack an own package, such we could simple
-say <tt>package require stack</tt>, or to save the definition of a stack
-simply in a file and load it via <tt>source</tt>.</p></div>
+say <code>package require stack</code>, or to save the definition of a stack
+simply in a file and load it via <code>source</code>.</p></div>
 <div class="paragraph"><p>In line 12 we create an instance of the stack, namely the stack object
-<tt>s1</tt>. The object <tt>s1</tt> is an instance of <tt>Stack</tt> and has therefore
-access to its methods. The methods like <tt>push</tt> or <tt>pop</tt> can be invoked
+<code>s1</code>. The object <code>s1</code> is an instance of <code>Stack</code> and has therefore
+access to its methods. The methods like <code>push</code> or <code>pop</code> can be invoked
 via a command starting with the object name followed by the
-method name. In lines 13-15 we push on the stack the values <tt>a</tt>, then
-<tt>b</tt>, and <tt>c</tt>. In line 16 we output the result of the <tt>pop</tt> method
-using the Tcl command <tt>puts</tt>. We will see on standard output the
+method name. In lines 13-15 we push on the stack the values <code>a</code>, then
+<code>b</code>, and <code>c</code>. In line 16 we output the result of the <code>pop</code> method
+using the Tcl command <code>puts</code>. We will see on standard output the
 value+c+ (the last stacked item). The output of the line 17 is the
-value <tt>b</tt> (the previously stacked item). Finally, in line 18 we
+value <code>b</code> (the previously stacked item). Finally, in line 18 we
 destroy the object. This is not necessary here, but shows the life
-cycle of an object. In some respects, <tt>destroy</tt> is the counterpart of
-<tt>create</tt> from line 12.</p></div>
+cycle of an object. In some respects, <code>destroy</code> is the counterpart of
+<code>create</code> from line 12.</p></div>
 <div class="imageblock" id="fig-class-object" style="text-align:center;">
 <div class="content">
 <img src="object-class-appclass.png" alt="object-class-appclass.png" />
@@ -1020,11 +1014,11 @@
 </div>
 <div class="paragraph"><p></p></div>
 <div class="paragraph"><p><a href="#fig-class-object">Figure 4</a> shows the actual class and
-object structure of the first <tt>Stack</tt> example. Note that the common
-root class is <tt>nx::Object</tt> that contains methods for all objects.
-Since classes are as well objects in NX, <tt>nx::Class</tt> is a
-specialization of <tt>nx::Object</tt>. <tt>nx::Class</tt> provides methods for
-creating objects, such as the method <tt>create</tt> which is used to create
+object structure of the first <code>Stack</code> example. Note that the common
+root class is <code>nx::Object</code> that contains methods for all objects.
+Since classes are as well objects in NX, <code>nx::Class</code> is a
+specialization of <code>nx::Object</code>. <code>nx::Class</code> provides methods for
+creating objects, such as the method <code>create</code> which is used to create
 objects (and classes as well).</p></div>
 </div>
 <div class="sect2">
@@ -1036,14 +1030,13 @@
 methods defined in the class in the instances of the class.</p></div>
 <div class="paragraph"><p>In our next example, we introduce <em>generic objects</em> and <em>object
 specific methods</em>. With NX, we can define generic objects, which are
-instances of the most generic class <tt>nx::Object</tt> (sometimes called
-"common root class"). <tt>nx::Object</tt> is predefined and contains a
-minimal set of methods applicable to all NX objects.</p></div>
-<div class="paragraph"><p>In our second example, we will define a generic object named <tt>stack</tt>
-and provide methods for this object. The methods defined in our first
-example were methods provided by a class for objects. Now we defined
-object specific methods, which are methods applicable only to the
-object for which they are defined.</p></div>
+instances of the most generic class <code>nx::Object</code> (sometimes called
+<em>common root class</em>). <code>nx::Object</code> is predefined and contains a
+minimal set of methods applicable to all NX objects.  In this example,
+we define a generic object named <code>stack</code> and provide methods for this
+object. The methods defined above were methods provided by a class for
+objects. Now we define object specific methods, which are methods
+applicable only to the object for which they are defined.</p></div>
 <div class="paragraph" id="xmp-object-stack"><div class="title">Listing 5: Object stack</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1073,59 +1066,64 @@
  15
 </pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> stack {
 
-   <span class='nx-keyword'>:variable</span> things {}
+   <span class='nx-keyword'>:object</span> <span class='nx-keyword'>variable</span> things {}
 
-   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> push {thing} {
+   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> push {thing} {
       <span class='nx-keyword'>set</span> :things [<span class='nx-keyword'>linsert</span> <span class='nx-variable'>${</span><span class='nx-variable'>:things}</span> 0 <span class='nx-variable'>$thing</span>]
       <span class='nx-keyword'>return</span> <span class='nx-variable'>$thing</span>
    }
 
-   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> pop {} {
+   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> pop {} {
       <span class='nx-keyword'>set</span> top [<span class='nx-keyword'>lindex</span> <span class='nx-variable'>${</span><span class='nx-variable'>:things}</span> 0]
       <span class='nx-keyword'>set</span> :things [<span class='nx-keyword'>lrange</span> <span class='nx-variable'>${</span><span class='nx-variable'>:things}</span> 1 end]
       <span class='nx-keyword'>return</span> <span class='nx-variable'>$top</span>
    }
 }</pre></td></tr></table></div></div>
 <div class="paragraph"><p>The example in <a href="#xmp-object-stack">Listing 5</a> defines the
-object <tt>stack</tt> in a very similar way as the class <tt>Stack</tt>. But the
+object <code>stack</code> in a very similar way as the class <code>Stack</code>. But the
 following points are different.</p></div>
 <div class="ulist"><ul>
 <li>
 <p>
-First, we use <tt>nx::Object</tt> instead of <tt>nx::Class</tt> to denote
+First, we use <code>nx::Object</code> instead of <code>nx::Class</code> to denote
   that we want to create a generic object, not a class.
 </p>
 </li>
 <li>
 <p>
-As in the example above, we use <tt>:variable</tt> to define the
-  instance variable <tt>things</tt> for this object (the object <tt>stack</tt>).
+We use <code>:object variable</code> to define the variable <code>things</code>  just for
+   this single instance  (the object <code>stack</code>).
 </p>
 </li>
+<li>
+<p>
+The definition for the methods <code>push</code> and <code>pop</code> are the same as
+  before, but here we defined these with <code>object method</code>. Therefore,
+  these two methods <code>push</code> and <code>pop</code> are object-specific.
+</p>
+</li>
 </ul></div>
-<div class="paragraph"><p>The definition for the methods <tt>push</tt> and <tt>pop</tt> are the same as
-before, but this times these methods are object-specific (in general,
-all methods defined for an object are object-specific). In order to use
-the stack, we can use directly the object <tt>stack</tt> in the same way as
-we have used the object <tt>s1</tt> in <a href="#xmp-using-stack">Listing 3</a>
-the class diagram for this the object <tt>stack</tt>.</p></div>
+<div class="paragraph"><p>In order to use
+the stack, we can use directly the object <code>stack</code> in the same way as
+we have used the object <code>s1</code> in <a href="#xmp-using-stack">Listing 3</a>
+the class diagram for this the object <code>stack</code>.</p></div>
 <div class="imageblock" id="img-object-stack" style="text-align:center;">
 <div class="content">
 <img src="object-stack.png" alt="object-stack.png" />
 </div>
 <div class="title">Figure 6. Object stack</div>
 </div>
 <div class="paragraph"><p></p></div>
-<div class="paragraph"><p>A reader might wonder when to use a class <tt>Stack</tt> or rather an object
-<tt>stack</tt>. A big difference is certainly that one can define easily
+<div class="paragraph"><p>A reader might wonder when to use a class <code>Stack</code> or rather an object
+<code>stack</code>. A big difference is certainly that one can define easily
 multiple instances of a class, while the object is actually a
-singleton. The concept of the object <tt>stack</tt> is similar to a module,
+single, tailored entity. The concept of the object <code>stack</code> is similar to a module,
 providing a certain functionality via a common interface, without
 providing the functionality to create multiple instances. The reuse of
 methods provided by the class to objects is as well a difference. If
 the methods of the class are updated, all instances of the class will
 immediately get the modified behavior. However, this does not mean that
-the reuse for the methods of <tt>stack</tt> is not possible. NX allows for
+the reuse for the methods of <code>stack</code> is not possible. NX allows for
 example to copy objects (similar to prototype based languages) or to
 reuse methods via e.g. aliases (more about this later).</p></div>
 <div class="paragraph"><p>Note that we use capitalized names for classes and lowercase names for
@@ -1136,15 +1134,15 @@
 <h3 id="_implementing_features_using_mixin_classes">2.3. Implementing Features using Mixin Classes</h3>
 <div class="paragraph"><p>So far, the definition of the stack methods was pretty minimal.
 Suppose, we want to define "safe stacks" that protect e.g. against
-stack under-runs (a stack under-run happens, when more <tt>pop</tt> than
-<tt>push</tt> operations are issued on a stack). Safety checking can be
+stack under-runs (a stack under-run happens, when more <code>pop</code> than
+<code>push</code> operations are issued on a stack). Safety checking can be
 implemented mostly independent from the implementation details of the
 stack (usage of internal data structures). There are as well different
 ways of checking the safety. Therefore we say that safety checking is
 orthogonal to the stack core implementation.</p></div>
 <div class="paragraph"><p>With NX we can define stack-safety as a separate class using methods
 with the same names as the implementations before, and "mix" this
-behavior into classes or objects. The implementation of <tt>Safety</tt> in
+behavior into classes or objects. The implementation of <code>Safety</code> in
 stack under-runs and to issue error messages, when this happens.</p></div>
 <div class="paragraph" id="xmp-class-safety"><div class="title">Listing 7: Class Safety</div><p></p></div>
 <div class="listingblock">
@@ -1206,18 +1204,18 @@
     <span class='nx-keyword'>next</span>
   }
 }</pre></td></tr></table></div></div>
-<div class="paragraph"><p>Note that all the methods of the class <tt>Safety</tt> end with <tt>next</tt>.
+<div class="paragraph"><p>Note that all the methods of the class <code>Safety</code> end with <code>next</code>.
 This command is a primitive command of NX, which calls the
 same-named method with the same argument list as the current
 invocation.</p></div>
-<div class="paragraph"><p>Assume we save the definition of the class <tt>Stack</tt> in a file named
-<tt>Stack.tcl</tt> and the definition of the class <tt>Safety</tt> in a file named
-<tt>Safety.tcl</tt> in the current directory. When we load the classes
-<tt>Stack</tt> and <tt>Safety</tt> into the same script (see the terminal dialog in
-e.g. a certain stack <tt>s2</tt> as a safe stack, while all other stacks
-(such as <tt>s1</tt>) might be still "unsafe". This can be achieved via the
-option <tt>-mixin</tt> at the object creation time (see line 9 in
-option <tt>-mixin</tt> mixes the class <tt>Safety</tt> into the new instance <tt>s2</tt>.</p></div>
+<div class="paragraph"><p>Assume we save the definition of the class <code>Stack</code> in a file named
+<code>Stack.tcl</code> and the definition of the class <code>Safety</code> in a file named
+<code>Safety.tcl</code> in the current directory. When we load the classes
+<code>Stack</code> and <code>Safety</code> into the same script (see the terminal dialog in
+e.g. a certain stack <code>s2</code> as a safe stack, while all other stacks
+(such as <code>s1</code>) might be still "unsafe". This can be achieved via the
+option <code>-mixin</code> at the object creation time (see line 9 in
+option <code>-mixin</code> mixes the class <code>Safety</code> into the new instance <code>s2</code>.</p></div>
 <div class="paragraph" id="xmp-using-class-safety"><div class="title">Listing 8: Using the Class Safety</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1260,7 +1258,7 @@
 ::Safety
 % Stack <span class='nx-keyword'>create</span> s1
 ::s1
-% Stack <span class='nx-keyword'>create</span> s2 -mixin Safety
+% Stack <span class='nx-keyword'>create</span> s2 -object-mixin Safety
 ::s2
 % s2 push a
 a
@@ -1274,35 +1272,38 @@
 
 % s2 <span class='nx-keyword'>info</span> precedence
 ::Safety ::Stack ::nx::Object</pre></td></tr></table></div></div>
-<div class="paragraph"><p>When the method <tt>push</tt> of <tt>s2</tt> is called, first the method of the
-mixin class <tt>Safety</tt> will be invoked that increments the counter and
-continues with <tt>next</tt> to call the shadowed method, here the method
-<tt>push</tt> of the <tt>Stack</tt> implementation that actually pushes the item.
-The same happens, when <tt>s2 pop</tt> is invoked, first the method of
-<tt>Safety</tt> is called, then the method of the <tt>Stack</tt>. When the stack is
-empty (the value of <tt>count</tt> reaches 0), and <tt>pop</tt> is invoked, the
-mixin class <tt>Safety</tt> generates an error message (raises an exception),
-and does not invoke the method of the <tt>Stack</tt>.</p></div>
-<div class="paragraph"><p>The last two commands in <a href="#xmp-using-class-safety">Listing 8</a> use introspection to query for the objects
-<tt>s1</tt> and <tt>s2</tt> in which order the involved classes are processed. This
-order is called the <tt>precedence order</tt> and is obtained via <tt>info
-precedence</tt>. We see that the mixin class <tt>Safety</tt> is only in use for
-<tt>s2</tt>, and takes there precedence over <tt>Stack</tt>. The common root class
-<tt>nx::Object</tt> is for both <tt>s1</tt> and <tt>s2</tt> the base class.</p></div>
+<div class="paragraph"><p>When the method <code>push</code> of <code>s2</code> is called, first the method of the
+mixin class <code>Safety</code> will be invoked that increments the counter and
+continues with <code>next</code> to call the shadowed method, here the method
+<code>push</code> of the <code>Stack</code> implementation that actually pushes the item.
+The same happens, when <code>s2 pop</code> is invoked, first the method of
+<code>Safety</code> is called, then the method of the <code>Stack</code>. When the stack is
+empty (the value of <code>count</code> reaches 0), and <code>pop</code> is invoked, the
+mixin class <code>Safety</code> generates an error message (raises an exception),
+and does not invoke the method of the <code>Stack</code>.</p></div>
+<div class="paragraph"><p>The last two commands in
+<a href="#xmp-using-class-safety">Listing 8</a>
+use introspection to query for the objects
+<code>s1</code> and <code>s2</code> in which order the involved classes are processed. This
+order is called the <code>precedence order</code> and is obtained via <code>info
+precedence</code>. We see that the mixin class <code>Safety</code> is only in use for
+<code>s2</code>, and takes there precedence over <code>Stack</code>. The common root class
+<code>nx::Object</code> is for both <code>s1</code> and <code>s2</code> the base class.</p></div>
 <div class="imageblock" id="img-per-object-mixin" style="text-align:center;">
 <div class="content">
 <img src="per-object-mixin.png" alt="per-object-mixin.png" />
 </div>
 <div class="title">Figure 9. Per-object Mixin</div>
 </div>
 <div class="paragraph"><p></p></div>
-<div class="paragraph"><p>Note that the class <tt>Safety</tt> is only mixed into a single object (here
-<tt>s2</tt>), therefore we refer to this case as a <em>per-object mixin</em>.
+<div class="paragraph"><p>Note that in <a href="#xmp-using-class-safety">Listing 8</a>,
+the class <code>Safety</code> is only mixed into a single object (here
+<code>s2</code>), therefore we refer to this case as a <em>per-object mixin</em>.
 <a href="#img-per-object-mixin">Figure 9</a> shows the class
-diagram, where the class <tt>Safety</tt> is used as a per-object mixin for
-<tt>s2</tt>.</p></div>
-<div class="paragraph"><p>The class <tt>Safety</tt> can be used as well in other ways, such as e.g. for
-defining classes for safe stacks &lt;&lt;xmp-class-safestack,</p></div>
+diagram, where the class <code>Safety</code> is used as a per-object mixin for
+<code>s2</code>.</p></div>
+<div class="paragraph"><p>The mixin class <code>Safety</code> can be used as well in other ways, such as e.g. for
+defining classes of safe stacks:</p></div>
 <div class="paragraph" id="xmp-class-safestack"><div class="title">Listing 10: Class SafeStack</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1329,28 +1330,32 @@
 </span><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> SafeStack -superclass Stack -mixin Safety
 
 SafeStack <span class='nx-keyword'>create</span> s3</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The difference to the case with the per-object mixin is that now,
-<tt>Safety</tt> is mixed into the definition of <tt>SafeStack</tt>. Therefore, all
-instances of the class <tt>SafeStack</tt> (here the instance <tt>s3</tt>) will be
-using the safety definitions.
-for this definition.</p></div>
+<div class="paragraph"><p>The difference of a per-class mixin and an per-object mixin is that
+the per-class mixin is applicable to all instances of the
+class. Therefore, we call these mixins also sometimes instance mixins.
+In our example in <a href="#xmp-class-safestack">Listing 10</a>,
+<code>Safety</code> is mixed into the definition of
+<code>SafeStack</code>. Therefore, all instances of the class <code>SafeStack</code> (here
+the instance <code>s3</code>) will be using the safety definitions.</p></div>
 <div class="imageblock" id="img-per-class-mixin" style="text-align:center;">
 <div class="content">
 <img src="per-class-mixin.png" alt="per-class-mixin.png" />
 </div>
 <div class="title">Figure 11. Per-class Mixin</div>
 </div>
 <div class="paragraph"><p></p></div>
-<div class="paragraph"><p>Note that we could use <tt>Safety</tt> as well as a per-class mixin on
-<tt>Stack</tt>. In this case, all stacks would be safe stacks and we could
+<div class="paragraph"><p><a href="#img-per-class-mixin">Figure 11</a> shows the class diagram
+for this definition.
+Note that we could use <code>Safety</code> as well as a per-class mixin on
+<code>Stack</code>. In this case, all stacks would be safe stacks and we could
 not provide a selective feature selection (which might be perfectly
 fine).</p></div>
 </div>
 <div class="sect2">
 <h3 id="_define_different_kinds_of_stacks">2.4. Define Different Kinds of Stacks</h3>
-<div class="paragraph"><p>The definition of <tt>Stack</tt> is generic and allows all kind of elements
+<div class="paragraph"><p>The definition of <code>Stack</code> is generic and allows all kind of elements
 to be stacked. Suppose, we want to use the generic stack definition,
-but a certain stack (say, stack <tt>s4</tt>) should be a stack for integers
+but a certain stack (say, stack <code>s4</code>) should be a stack for integers
 only. This behavior can be achieved by the same means as introduced
 already in <a href="#xmp-object-stack">Listing 5</a>, namely
 object-specific methods.</p></div>
@@ -1384,23 +1389,23 @@
 </span>  <span class='nx-comment'># to check the type of entries
 </span>  <span class='nx-comment'>#
 </span>
-  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> push {thing:integer} {
+  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> push {thing:integer} {
     <span class='nx-keyword'>next</span>
   }
 }</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The program snippet in <a href="#xmp-object-integer-stack">Listing 12</a> defines an instance <tt>s4</tt> of the class
-<tt>Stack</tt> and provides an object specific method for <tt>push</tt> to implement
-an integer stack. The method <tt>pull</tt> is the same for the integer stack
+<div class="paragraph"><p>The program snippet in <a href="#xmp-object-integer-stack">Listing 12</a> defines an instance <code>s4</code> of the class
+<code>Stack</code> and provides an object specific method for <code>push</code> to implement
+an integer stack. The method <code>pull</code> is the same for the integer stack
 as for all other stacks, so it will be reused as usual from the class
-<tt>Stack</tt>. The object-specific method <tt>push</tt> of <tt>s4</tt> has a value
-constraint in its argument list (<tt>thing:integer</tt>) that makes sure,
+<code>Stack</code>. The object-specific method <code>push</code> of <code>s4</code> has a value
+constraint in its argument list (<code>thing:integer</code>) that makes sure,
 that only integers can be stacked. In case the argument is not an
 integer, an exception will be raised. Of course, one could perform the
-value constraint checking as well in the body of the method <tt>proc</tt> by
+value constraint checking as well in the body of the method <code>proc</code> by
 accepting an generic argument and by performing the test for the value
 in the body of the method. In the case, the passed value is an
-integer, the <tt>push</tt> method of <a href="#xmp-object-integer-stack">Listing 12</a> calls <tt>next</tt>, and therefore calls the
-shadowed generic definition of <tt>push</tt> as provided by <tt>Stack</tt>.</p></div>
+integer, the <code>push</code> method of <a href="#xmp-object-integer-stack">Listing 12</a> calls <code>next</code>, and therefore calls the
+shadowed generic definition of <code>push</code> as provided by <code>Stack</code>.</p></div>
 <div class="paragraph" id="xmp-class-integer-stack"><div class="title">Listing 13: Class IntegerStack</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1435,27 +1440,24 @@
 }</pre></td></tr></table></div></div>
 <div class="paragraph"><p>An alternative approach is shown in
 <a href="#xmp-class-integer-stack">Listing 13</a>, where the class
-<tt>IntegerStack</tt> is defined, using the same method definition
-as <tt>s4</tt>, this time on the class level.</p></div>
+<code>IntegerStack</code> is defined, using the same method definition
+as <code>s4</code>, this time on the class level.</p></div>
 </div>
 <div class="sect2">
-<h3 id="_define_class_specific_methods">2.5. Define Class Specific Methods</h3>
+<h3 id="_define_object_specific_methods_on_classes">2.5. Define Object Specific Methods on Classes</h3>
 <div class="paragraph"><p>In our previous examples we defined methods provided by classes
 (applicable for their instances) and object-specific methods (methods
 defined on objects, which are only applicable for these objects). In
-this section, we introduce methods that are defined on classes. These
-method are only applicable for the class objects. Such methods are
-sometimes called <em>class methods</em> or <em>static methods</em>.</p></div>
-<div class="paragraph"><p>In NX classes are objects with certain properties. The classes are
-objects providing methods for instance and which are managing the
-life-cycles of the objects (we will come to this point in later
-sections in more detail). Since classes are objects, it is also
-possible to define object-specific methods for the class
-objects. However, since <tt>:method</tt> applied on classes defines methods
-for instances, we have to use the method-modifier <tt>class</tt> to denote
-methods to be applied on the class itself. Note that instances do not
-inherit class methods. The methods defined on the class object are
-actually exactly same as the object-specific methods shown in the
+this section, we introduce methods that are defined on the class
+objects. Such methods are sometimes called <em>class methods</em> or
+<em>static methods</em>.</p></div>
+<div class="paragraph"><p>In NX classes are objects, they are specialized objects with
+additional methods. Methods for classes are often used for managing
+the life-cycles of the instances of the classes (we will come to this
+point in later sections in more detail). Since classes are objects, we
+can use exactly the same notation as above to define class methods by
+using <code>object method</code>. The methods defined on the class object are
+in all respects identical with object specific methods shown in the
 examples above.</p></div>
 <div class="paragraph" id="xmp-stack2"><div class="title">Listing 14: Class Stack2</div><p></p></div>
 <div class="listingblock">
@@ -1495,7 +1497,7 @@
  24
 </pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Stack2 {
 
-   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>class</span> <span class='nx-keyword'>method</span> available_stacks {} {
+   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> available_stacks {} {
       <span class='nx-keyword'>return</span> [<span class='nx-keyword'>llength</span> [<span class='nx-keyword'>:info</span> instances]]
    }
 
@@ -1517,10 +1519,10 @@
 Stack2 <span class='nx-keyword'>create</span> s2
 
 <span class='nx-keyword'>puts</span> [Stack2 available_stacks]</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The class <tt>Stack2</tt> in <a href="#xmp-stack2">Listing 14</a> consists of the
-earlier definition of the class <tt>Stack</tt> and is extended by the
-class-specific method <tt>available_stacks</tt>, which returns the
-current number of instances of the stack. The final command <tt>puts</tt>
+<div class="paragraph"><p>The class <code>Stack2</code> in <a href="#xmp-stack2">Listing 14</a> consists of the
+earlier definition of the class <code>Stack</code> and is extended by the
+class-specific method <code>available_stacks</code>, which returns the
+current number of instances of the stack. The final command <code>puts</code>
 (line 26) prints 2 to the console.</p></div>
 <div class="imageblock" id="img-stack2" style="text-align:center;">
 <div class="content">
@@ -1531,8 +1533,8 @@
 <div class="paragraph"><p></p></div>
 <div class="paragraph"><p>The class diagram in <a href="#img-stack2">Figure 15</a> shows the
 diagrammatic representation of the class object-specific method
-<tt>available_stacks</tt>.  Since every class is a specialization of the
-common root class <tt>nx::Object</tt>, the common root class is often omitted
+<code>available_stacks</code>.  Since every class is a specialization of the
+common root class <code>nx::Object</code>, the common root class is often omitted
 from the class diagrams, so it was omitted here as well in the diagram.</p></div>
 </div>
 </div>
@@ -1544,25 +1546,25 @@
 <h3 id="_variables_and_properties">3.1. Variables and Properties</h3>
 <div class="paragraph"><p>In general, NX does not need variable declarations. It allows to
 create or modify variables on the fly by using for example the Tcl
-commands <tt>set</tt> and <tt>unset</tt>. Depending on the variable name (or more
+commands <code>set</code> and <code>unset</code>. Depending on the variable name (or more
 precisely, depending on the variable name&#8217;s prefix consisting of
-colons <tt>:</tt>) a variable is either local to a method, or it is an
+colons "<code>:</code>") a variable is either local to a method, or it is an
 instance variable, or a global variable.  The rules are:</p></div>
 <div class="ulist"><ul>
 <li>
 <p>
 A variable without any colon prefix refers typically to a method
    scoped variable. Such a variable is created during the invocation
    of the method, and it is deleted, when the method ends.  In the
-   example below, the variable <tt>a</tt> is method scoped.
+   example below, the variable <code>a</code> is method scoped.
 </p>
 </li>
 <li>
 <p>
 A variable with a single colon prefix refers to an instance
     variable.  An instance variable is part of the object; when the
     object is destroyed, its instance variables are deleted as well. In the
-    example below, the variable <tt>b</tt> is an instance variable.
+    example below, the variable <code>b</code> is an instance variable.
 </p>
 </li>
 <li>
@@ -1571,7 +1573,7 @@
   lifespan of a globale variable ends when the variable is explicitly
   unset or the script terminates. Variables, which are placed in Tcl
   namespaces, are also global variables. In the example below, the
-  variable <tt>c</tt> is a global variable.
+  variable <code>c</code> is a global variable.
 </p>
 </li>
 </ul></div>
@@ -1609,37 +1611,43 @@
 </span>    <span class='nx-keyword'>set</span> ::c 3
   }
 }</pre></td></tr></table></div></div>
-<div class="paragraph"><p><a href="#xmp-var-resolver">Listing 16</a> shows a method <tt>foo</tt>
-of some class <tt>Foo</tt> referring to differently scoped variables.</p></div>
+<div class="paragraph"><p><a href="#xmp-var-resolver">Listing 16</a> shows a method <code>foo</code>
+of some class <code>Foo</code> referring to differently scoped variables.</p></div>
 <div class="sect3">
-<h4 id="_properties_instance_variables_with_accessors">3.1.1. Properties: Instance Variables with Accessors</h4>
-<div class="paragraph"><p>Generally, there is no need to define or declare instance variables in
-NX. In some cases, however, a definition of instance variables is
-useful. NX allows us to define instances variables as <em>properties</em> on
-classes, which are inherited to subclasses. Furthermore, the
-definition of properties can be used the check permissible values for
-instance variables or to initialize instance variables from default
-values during object initialization.</p></div>
+<h4 id="_properties_configurable_instance_variables">3.1.1. Properties: Configurable Instance Variables</h4>
+<div class="paragraph"><p>As described above, there is no need to declare instance variables in
+NX. In many cases, a developer might want to define some value
+constraints for variables, or to provide defaults, or to make
+variables configurable upon object creation. Often, variables are
+"inherited", meaning that the variables declared in a general class
+are also available in a more specialized class. For these purposes NX
+provides <em>variable handlers</em> responsible for the management of
+instance variables. We distinguish in NX between configurable
+variables (called <code>property</code>) and variables that are not configurable
+(called <code>variable</code>).</p></div>
 <div class="exampleblock">
 <div class="content">
-<div class="paragraph"><p>A <strong>property</strong> is a definition of an attribute (an instance variable)
-with accessor methods. A property definition might carry
-value-constraints and a default value.</p></div>
+<div class="paragraph"><p>A <strong>property</strong> is a definition of a configurable instance variable.</p></div>
 </div></div>
+<div class="paragraph"><p>The term configurable means that (a) one can provide at creation time of
+an instance a value for this variable, and (b), one can query the
+value via the accessor function <code>cget</code> and (c), one can change the
+value of the variable via <code>configure</code> at runtime. Since the general
+accessor function <code>cget</code> and <code>configure</code> are available, an application
+developer does not have to program own accessor methods. When value
+checkers are provided, each time, the value of the variable is to be
+changed, the constrained are checked as well.</p></div>
 <div class="imageblock" id="img-person-student" style="text-align:center;">
 <div class="content">
 <img src="person-student.png" alt="person-student.png" />
 </div>
 <div class="title">Figure 17. Classes Person and Student</div>
 </div>
 <div class="paragraph"><p></p></div>
-<div class="paragraph"><p>The class diagram above defines the classes <tt>Person</tt> and
-<tt>Student</tt>. For both classes, accessor methods are specified with the
-same names as the attributes. (Note that we show the accessor methods
-only in this example, we omit it in later ones). By defining
-properties we can use the name of the attribute as method name to
-access the attributes. The listing below shows an implementation of this
-conceptual model in NX.</p></div>
+<div class="paragraph"><p>The class diagram above defines the classes <code>Person</code> and
+<code>Student</code>. For both classes, configurable instance variable are
+specified by defining these as properties. The listing below shows
+an implementation of this conceptual model in NX.</p></div>
 <div class="paragraph" id="xmp-properties"><div class="title">Listing 18: Properties</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1698,47 +1706,58 @@
 }
 
 <span class='nx-comment'>#
-</span><span class='nx-comment'># Create instances using object parameters
+</span><span class='nx-comment'># Create instances using configure parameters
 </span><span class='nx-comment'># for the initialization
 </span><span class='nx-comment'>#
 </span>Person <span class='nx-keyword'>create</span> p1 -name Bob
 Student <span class='nx-keyword'>create</span> s1 -name Susan -matnr 4711
 
 <span class='nx-comment'># Access property value via accessor method
-</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 name]"</span></pre></td></tr></table></div></div>
-<div class="paragraph"><p>By defining <tt>name</tt> and <tt>birthday</tt> as properties of <tt>Person</tt>, NX
-provides automatically accessor methods with the same name.  The
-accessors methods (or shortly called "accessors") provide read and
-write access to the underlying instance variables. In our example, the
-class <tt>Person</tt> has two methods implied by the <tt>property</tt> definition:
-the method <tt>name</tt> and the method <tt>birthday</tt>.</p></div>
-<div class="paragraph"><p>The class <tt>Student</tt> is defined as a specialization of <tt>Person</tt> with
-two additional properties: <tt>matnr</tt> and <tt>oncampus</tt>. The property
-<tt>matnr</tt> is required (it has to be provided, when an instance of this
-class is created), and the property <tt>oncampus</tt> is boolean, and is per
-default set to <tt>true</tt>. Note that the class <tt>Student</tt> inherits the
-properties of <tt>Person</tt>. So, <tt>Student</tt> has four properties in total.</p></div>
-<div class="paragraph"><p>The property definitions are also used to providing <tt>object
-parameters</tt>. These are typically non-positional parameters, which are
-used during object creation to supply values to the instance
-variables. In our listing, we create an instance of <tt>Person</tt> using the
-object parameter <tt>name</tt> and provide the value of <tt>Bob</tt> to the instance
-variable <tt>name</tt>.  Similarly, we create an instance of <tt>Student</tt> using
-the two object parameters <tt>name</tt> and <tt>matnr</tt>. Finally, we use the
-accessor method <tt>name</tt> to obtain the value of the instance variable
-<tt>name</tt> of object <tt>s1</tt>.</p></div>
+</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 cget -name]"</span></pre></td></tr></table></div></div>
+<div class="paragraph"><p>By defining <code>name</code> and <code>birthday</code> as properties of <code>Person</code>, NX makes
+these configurable.  When we create an instance of <code>Person</code> named
+<code>p1</code>, we can provide a value for e.g. the name by specifying <code>-name</code>
+during creation. The properties result in non-positional configure parameters
+which can be provided in any order. In our listing, we create an instance of
+<code>Person</code> using the configure  parameter <code>name</code> and provide the value of
+<code>Bob</code> to the instance variable <code>name</code>.</p></div>
+<div class="paragraph"><p>The class <code>Student</code> is defined as a specialization of <code>Person</code> with
+two additional properties: <code>matnr</code> and <code>oncampus</code>. The property
+<code>matnr</code> is required (it has to be provided, when an instance of this
+class is created), and the property <code>oncampus</code> is boolean, and is per
+default set to <code>true</code>. Note that the class <code>Student</code> inherits the
+properties of <code>Person</code>. So, <code>Student</code> has four properties in total.</p></div>
+<div class="paragraph"><p>The property definitions provide the <code>configure parameters</code> for
+instance creation. Many other languages require such parameters to be
+passed via arguments of a constructor, which is often error prone,
+when values are to be passed to superclasses. Also in dynamic
+languages, the relationships between classes can be easily changed,
+and different superclasses might have different requirements in their
+constructors. The declarative approach in NX reduces the need for
+tailored constructor methods significantly.</p></div>
+<div class="paragraph"><p>Note, that the property <code>matnr</code> of class <code>Student</code> is required. This
+means, that if we try to create an instance of <code>Student</code>, a runtime
+exception will be triggered. The property <code>oncamups</code> is boolean and
+contains a default value. Providing a default value means that
+whenever we create an instance of this class the object will contain
+such an instance variable, even when we provide no value via the
+configure parameters.</p></div>
+<div class="paragraph"><p>In our listing, we create an instance of <code>Student</code> using the two
+configure parameters <code>name</code> and <code>matnr</code>. Finally, we use method <code>cget</code>
+to obtain the value of the instance variable <code>name</code> of object <code>s1</code>.</p></div>
 </div>
 <div class="sect3">
-<h4 id="_instance_variables_without_accessors">3.1.2. Instance Variables without Accessors</h4>
-<div class="paragraph"><p>To define instances variables with default values without accessors
-the predefined method <tt>variable</tt> can be used. Such instance variables
-are often used for e.g. keeping the internal state of an object.  The
-usage of <tt>variable</tt> is in many respects similar to <tt>property</tt>. One
-difference is, that <tt>property</tt> uses the same syntax as for method
-parameters, whereas <tt>variable</tt> receives the default value as a separate
-argument (similar to the <tt>variable</tt> command in Tcl). The introductory
-Stack example in <a href="#xmp-class-stack">Listing 2</a> uses already
-the method <tt>variable</tt>.</p></div>
+<h4 id="_non_configurable_instance_variables">3.1.2. Non-configurable Instance Variables</h4>
+<div class="paragraph"><p>In practice, not all instance variables should be configurable. But
+still, we want to be able to provide defaults similar to
+properties. To define non-configurable instance variables the
+predefined method <code>variable</code> can be used. Such instance variables are
+often used for e.g. keeping the internal state of an object.  The
+usage of <code>variable</code> is in many respects similar to <code>property</code>. One
+difference is, that <code>property</code> uses the same syntax as for method
+parameters, whereas <code>variable</code> receives the default value as a
+separate argument (similar to the <code>variable</code> command in plain
+Tcl). The introductory Stack example in <a href="#xmp-class-stack">Listing 2</a> uses already the method <code>variable</code>.</p></div>
 <div class="paragraph" id="xmp-variable"><div class="title">Listing 19: Declaring Variables</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1783,8 +1802,10 @@
 </span><span class='nx-comment'># x == 1 and y == 2</span></pre></td></tr></table></div></div>
 <div class="paragraph"><p>Note that the variable definitions are inherited in the same way as
 properties. The example in <a href="#xmp-variable">Listing 19</a> shows a
-class <tt>Derived</tt> that inherits from <tt>Base</tt>. When an instance <tt>d1</tt> is
-created, it will contain the two instance variables <tt>x</tt> and <tt>y</tt>.</p></div>
+class <code>Derived</code> that inherits from <code>Base</code>. When an instance <code>d1</code> is
+created, it will contain the two instance variables <code>x</code> and <code>y</code>.
+Note that the variable declarations from <code>property</code> and <code>variable</code> are
+used to initialize (and to configure) the instances variables of an object.</p></div>
 <div class="paragraph" id="xmp-constructor"><div class="title">Listing 20: Setting Variables in the Constructor</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1836,11 +1857,16 @@
 <span class='nx-comment'># Create instance of the class Derived2
 </span>Derived2 <span class='nx-keyword'>create</span> d2</pre></td></tr></table></div></div>
 <div class="paragraph"><p>In many other object oriented languages, the instance variables are
-initialized solely by the constructor (similar to class <tt>Derived2</tt> in
+initialized solely by the constructor (similar to class <code>Derived2</code> in
 <a href="#xmp-constructor">Listing 20</a>). This approach is certainly
 also possible in NX. Note that the approach using constructors
 requires an explicit method chaining between the constructors and is
-less declarative than the approach in NX using <tt>property</tt> and <tt>variable</tt>.</p></div>
+less declarative than the approach in NX using <code>property</code> and <code>variable</code>.</p></div>
+<div class="paragraph"><p>Both, <code>property</code> and <code>variable</code> provide much more functionalities. One
+can for example declare <code>public</code>, <code>protected</code> or <code>private</code> accessor
+methods, or one can define variables to be incremental (for
+e.g. adding values to a list of values), or one can define variables
+specific behavior.</p></div>
 </div>
 </div>
 <div class="sect2">
@@ -1904,21 +1930,21 @@
 
 <span class='nx-comment'># The following line prints "::fido Bark, bark, bark."
 </span>fido bark</pre></td></tr></table></div></div>
-<div class="paragraph"><p>In the example above we create a class <tt>Dog</tt> with a scripted method
-named <tt>bark</tt>. The method body defines the code, which is executed when
-the method is invoked. In this example, the method <tt>bar</tt> prints out a
+<div class="paragraph"><p>In the example above we create a class <code>Dog</code> with a scripted method
+named <code>bark</code>. The method body defines the code, which is executed when
+the method is invoked. In this example, the method <code>bar</code> prints out a
 line on the terminal starting with the object name (this is determined
-by the built in command <tt>self</tt>) followed by "Bark, bark, bark.".  This
+by the built in command <code>self</code>) followed by "Bark, bark, bark.".  This
 method is defined on a class and applicable to instances of the class
-(here the instance <tt>fido</tt>).</p></div>
+(here the instance <code>fido</code>).</p></div>
 </div>
 <div class="sect3">
 <h4 id="_c_implemented_methods">3.2.2. C-implemented Methods</h4>
 <div class="paragraph"><p>Not all of the methods usable in NX are scripted methods; many
 predefined methods are defined in the underlying system language,
 which is typically C.  For example, in <a href="#xmp-fido1">Listing 21</a> we
-used the method <tt>create</tt> to create the class <tt>Dog</tt> and to create the
-dog instance <tt>fido</tt>. These methods are implemented in C in the next
+used the method <code>create</code> to create the class <code>Dog</code> and to create the
+dog instance <code>fido</code>. These methods are implemented in C in the next
 scripting framework.</p></div>
 <div class="paragraph"><p>C-implemented methods are not only provided by the underlying
 framework but might be as well defined by application developers. This
@@ -1928,15 +1954,18 @@
 <em>aliases</em>.</p></div>
 <div class="exampleblock">
 <div class="content">
-<div class="paragraph"><p>An <strong>accessor method</strong> is in most cases a C-implemented method that
-accesses instance variables of an object. A call to an accessor
+<div class="paragraph"><p>An <strong>accessor method</strong> is a method that accesses instance
+variables of an object. A call to an accessor
 without arguments uses the accessor as a getter, obtaining the actual
 value of the associated variable. A call to an accessor with an
 argument uses it as a setter, setting the value of the associated
 variable.</p></div>
 </div></div>
-<div class="paragraph"><p>Accessors have already been discussed in the section about properties,
-in which the accessors were created automatically.</p></div>
+<div class="paragraph"><p>NX provides support for C-implemented accessor methods. Accessors have
+already been mentioned in the section about properties. When
+the option <code>-accessor public|protected|private</code> is provided to a
+<code>variable</code> or <code>property</code> definition, NX creates automatically a
+same-named accessors method.</p></div>
 <div class="paragraph" id="xmp-fido2"><div class="title">Listing 22: Accessor Methods</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -1980,7 +2009,7 @@
 }
 
 <span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Tail {
-  <span class='nx-keyword'>:property</span> {length:double 5}
+  <span class='nx-keyword'>:property</span> -accessor <span class='nx-keyword'>public</span> {length:double 5}
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> wag {} {<span class='nx-keyword'>return</span> Joy}
 }
 
@@ -2000,12 +2029,13 @@
 <span class='nx-comment'># Proving an invalid values will raise an error
 </span>fido::tail length <span class='nx-string'>"Hello"</span></pre></td></tr></table></div></div>
 <div class="paragraph"><p><a href="#xmp-fido2">Listing 22</a> shows an extended example, where every dog
-has a tail. The object <tt>tail</tt> is created as a subobject of the dog in
-the constructor <tt>init</tt>. The subobject can be accessed by providing the
-full name of the subobject <tt>fido::tail</tt>. The method <tt>length</tt> is an
+has a tail. The object <code>tail</code> is created as a subobject of the dog in
+the constructor <code>init</code>. The subobject can be accessed by providing the
+full name of the subobject <code>fido::tail</code>. The method <code>length</code> is an
 C-implemented accessor, that enforces the value constraint (here a
 floating point number, since length uses the value constraint
-<tt>double</tt>).</p></div>
+<code>double</code>). Line 25 will therefore raise an exception, since the
+provided values cannot be converted to a double number.</p></div>
 <div class="paragraph" id="xmp-fido3"><div class="title">Listing 23: Forwarder Methods</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -2041,12 +2071,12 @@
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bark {} { <span class='nx-keyword'>puts</span> <span class='nx-string'>"[self] Bark, bark, bark."</span> }
   <span class='nx-keyword'>:method</span> <span class='nx-keyword'>init</span> {} {
     Tail <span class='nx-keyword'>create</span> [<span class='nx-keyword'>self</span>]::tail
-    <span class='nx-keyword'>:public</span> <span class='nx-keyword'>forward</span> wag [<span class='nx-keyword'>self</span>]::tail wag
+    <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>forward</span> wag [<span class='nx-keyword'>self</span>]::tail wag
   }
 }
 
 <span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> Tail {
-  <span class='nx-keyword'>:property</span> {length 5}
+  <span class='nx-keyword'>:property</span> -accessor <span class='nx-keyword'>public</span> {length 5}
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> wag {} {<span class='nx-keyword'>return</span> Joy}
 }
 
@@ -2057,9 +2087,9 @@
 </span><span class='nx-comment'># Therefore, the following method returns "Joy".
 </span>fido wag</pre></td></tr></table></div></div>
 <div class="paragraph"><p><a href="#xmp-fido3">Listing 23</a> again extends the example by adding a
-forwarder named <tt>wag</tt> to the object (e.g. <tt>fido</tt>). The forwarder
-redirects all calls of the form <tt>fido wag</tt> with arbitrary arguments to
-the subobject <tt>fido::tail</tt>.</p></div>
+forwarder named <code>wag</code> to the object (e.g. <code>fido</code>). The forwarder
+redirects all calls of the form <code>fido wag</code> with arbitrary arguments to
+the subobject <code>fido::tail</code>.</p></div>
 <div class="exampleblock">
 <div class="content">
 <div class="paragraph"><p>A <strong>forwarder method</strong> is a
@@ -2070,9 +2100,9 @@
 </div></div>
 <div class="paragraph"><p>The functionality of the forwarder can just as well be implemented as
 a scripted method, but for the most common cases, the forward
-implementation is more efficient, and the <tt>forward</tt> method expresses
+implementation is more efficient, and the <code>forward</code> method expresses
 the intention of the developer.</p></div>
-<div class="paragraph"><p>The method <tt>forwarder</tt> has several options to change e.g. the order of
+<div class="paragraph"><p>The method <code>forwarder</code> has several options to change e.g. the order of
 the arguments, or to substitute certain patterns in the argument list
 etc. This will be described in later sections.</p></div>
 </div>
@@ -2128,7 +2158,7 @@
 <span class='nx-comment'># The following line prints "::fido Bark, bark, bark."
 </span>fido warn</pre></td></tr></table></div></div>
 <div class="paragraph"><p><a href="#xmp-fido4">Listing 24</a> extends the last example by defining an
-alias for the method "bark". The example only shows the bare
+alias for the method <code>bark</code>. The example only shows the bare
 mechanism. In general, method aliases are very powerful means for
 reusing pre-existing functionality. The full object system of NX and
 XOTcl2 is built from aliases, reusing functionality provided by the
@@ -2142,15 +2172,15 @@
 The call-protection defines from which calling context methods might
 be called. The Next Scripting Framework supports as well redefinition
 protection for methods.</p></div>
-<div class="paragraph"><p>NX distinguishes between <tt>public</tt>, <tt>protected</tt> and <tt>private</tt> methods,
-where the default call-protection is <tt>protected</tt>.</p></div>
+<div class="paragraph"><p>NX distinguishes between <code>public</code>, <code>protected</code> and <code>private</code> methods,
+where the default call-protection is <code>protected</code>.</p></div>
 <div class="exampleblock">
 <div class="content">
 <div class="paragraph"><p>A <strong>public</strong> method can be called from every context. A <strong>protected</strong>
 method can only be invoked from the same object. A <strong>private</strong> method
 can only be invoked from methods defined on the same entity
 (defined on the same class or on the same object) via the invocation
-with the local flag (i.e. "<tt>: -local foo</tt>").</p></div>
+with the local flag (i.e. "<code>: -local foo</code>").</p></div>
 </div></div>
 <div class="paragraph"><p>All kind of method protections are applicable for all kind of methods,
 either scripted or C-implemented.</p></div>
@@ -2218,10 +2248,10 @@
 
 <span class='nx-comment'># The invocation of the protected method "helper" raises an error:
 </span>f1 helper</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The example above uses <tt>:protected method helper &#8230;</tt>. We could have
-used here as well <tt>:method helper &#8230;</tt>, since the default method
+<div class="paragraph"><p>The example above uses <code>:protected method helper &#8230;</code>. We could have
+used here as well <code>:method helper &#8230;</code>, since the default method
 call-protection is already protected.</p></div>
-<div class="paragraph"><p>The method call-protection of <tt>private</tt> goes one step further and
+<div class="paragraph"><p>The method call-protection of <code>private</code> goes one step further and
 helps to hide implementation details also for implementors of
 subclasses. Private methods are a means for avoiding unanticipated name
 clashes. Consider the following example:</p></div>
@@ -2265,31 +2295,31 @@
 s1 foo 3 4     ;<span class='nx-comment'># returns 7
 </span>s1 bar 3 4     ;<span class='nx-comment'># returns 12
 </span>s1 helper 3 4  ;<span class='nx-comment'># raises error: unable to dispatch method helper</span></pre></td></tr></table></div></div>
-<div class="paragraph"><p>The base class implements a public method <tt>foo</tt> using the helper
-method named <tt>helper</tt>. The derived class implements a as well a public
-method <tt>bar</tt>, which is also using a helper method named <tt>helper</tt>. When
-an instance <tt>s1</tt> is created from the derived class, the method <tt>foo</tt>
+<div class="paragraph"><p>The base class implements a public method <code>foo</code> using the helper
+method named <code>helper</code>. The derived class implements a as well a public
+method <code>bar</code>, which is also using a helper method named <code>helper</code>. When
+an instance <code>s1</code> is created from the derived class, the method <code>foo</code>
 is invoked which uses in turn the private method of the base
-class. Therefore, the invocation <tt>s1 foo 3 4</tt> returns its sum. If
-the <tt>local</tt> flag had not beed used in helper, <tt>s1</tt> would
-have tried to call the helper of <tt>Sub</tt>, which would be incorrect. For
+class. Therefore, the invocation <code>s1 foo 3 4</code> returns its sum. If
+the <code>local</code> flag had not beed used in helper, <code>s1</code> would
+have tried to call the helper of <code>Sub</code>, which would be incorrect. For
 all other purposes, the private methods are "invisible" in all
-situations, e.g., when mixins are used, or within the <tt>next</tt>-path, etc.</p></div>
-<div class="paragraph"><p>By using the <tt>-local</tt> flag at the call site it is possible to invoce
+situations, e.g., when mixins are used, or within the <code>next</code>-path, etc.</p></div>
+<div class="paragraph"><p>By using the <code>-local</code> flag at the call site it is possible to invoke
 only the local definition of the method. If we would call the method
 without this flag, the resolution order would be the standard
-resolution order, starting with filters, mixins, per-object methods
+resolution order, starting with filters, mixins, object methods
 and the full intrinsic class hierarchy.</p></div>
-<div class="paragraph"><p>NX supports the modifier <tt>private</tt> for methods and properties. In all
-cases <tt>private</tt> is an instrument to avoid unanticipated interactions
+<div class="paragraph"><p>NX supports the modifier <code>private</code> for methods and properties. In all
+cases <code>private</code> is an instrument to avoid unanticipated interactions
 and means actually "accessible for methods defined on the same entity
-(object or class)". The main usage for <tt>private</tt> is to improve
+(object or class)". The main usage for <code>private</code> is to improve
 locality of the code e.g. for compositional operations.</p></div>
 <div class="paragraph"><p>In order to improve locality for properties, a private property
-defines therfore internally a variable with a different name to avoid
+defines therefore internally a variable with a different name to avoid
 unintended interactions. The variable should be accessed via the
-private accessor, which can be invoved with the <tt>-local</tt> flag.  In the
-following example class <tt>D</tt> introduces a private property with the
+private accessor, which can be invoked with the <code>-local</code> flag.  In the
+following example class <code>D</code> introduces a private property with the
 same name as a property in the superclass.</p></div>
 <div class="paragraph" id="xmp-private-properties"><div class="title">Listing 27: Private Properties</div><p></p></div>
 <div class="listingblock">
@@ -2329,10 +2359,10 @@
  24
  25
 </pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
-</span><span class='nx-comment'># Define a class C with a (public) property "x"
+</span><span class='nx-comment'># Define a class C with a property "x" and a public accessor
 </span><span class='nx-comment'>#
 </span><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
-  <span class='nx-keyword'>:property</span> {x c}
+  <span class='nx-keyword'>:property</span> -accessor <span class='nx-keyword'>public</span> {x c}
 }
 
 <span class='nx-comment'>#
@@ -2341,7 +2371,7 @@
 </span><span class='nx-comment'># the private property.
 </span><span class='nx-comment'>#
 </span><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> D -superclass C {
-  <span class='nx-keyword'>:private</span> <span class='nx-keyword'>property</span> {x d}
+  <span class='nx-keyword'>:property</span> -accessor <span class='nx-keyword'>private</span> {x d}
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bar {p} {<span class='nx-keyword'>return</span> [: -local <span class='nx-variable'>$p</span>]}
 }
 
@@ -2353,10 +2383,10 @@
 </span>D <span class='nx-keyword'>create</span> d1
 <span class='nx-keyword'>puts</span> [d1 x]       ;<span class='nx-comment'># prints "c"
 </span><span class='nx-keyword'>puts</span> [d1 bar x]   ;<span class='nx-comment'># prints "d"</span></pre></td></tr></table></div></div>
-<div class="paragraph"><p>Without the <tt>private</tt> definition of the property, the definition of
-property <tt>x</tt> in class <tt>D</tt> would shadow the
-definition of the property in the superclass <tt>C</tt> for its instances
-(<tt>d1 x</tt> or <tt>set :x</tt> would return <tt>d</tt> instead of <tt>c</tt>).</p></div>
+<div class="paragraph"><p>Without the <code>private</code> definition of the property, the definition of
+property <code>x</code> in class <code>D</code> would shadow the
+definition of the property in the superclass <code>C</code> for its instances
+(<code>d1 x</code> or <code>set :x</code> would return <code>d</code> instead of <code>c</code>).</p></div>
 </div>
 <div class="sect2">
 <h3 id="_applicability_of_methods">3.4. Applicability of Methods</h3>
@@ -2371,8 +2401,8 @@
 class are applicable to the instances (direct or indirect) of this
 class. These methods are called <strong>instance methods</strong>.</p></div>
 </div></div>
-<div class="paragraph"><p>In the following example method, <tt>foo</tt> is an instance method defined
-on class <tt>C</tt>.</p></div>
+<div class="paragraph"><p>In the following example method, <code>foo</code> is an instance method defined
+on class <code>C</code>.</p></div>
 <div class="paragraph" id="xmp-instance-applicable"><div class="title">Listing 28: Methods applicable for instances</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -2408,17 +2438,17 @@
 <h4 id="_object_methods">3.4.2. Object Methods</h4>
 <div class="exampleblock">
 <div class="content">
-<div class="paragraph"><p>Methods defined on objects are <strong>per-object methods</strong>. Per-object
+<div class="paragraph"><p>Methods defined on objects are <strong>object methods</strong>. Object
 methods are only applicable on the object, on which they are defined.
-Per-object methods cannot be inherited from other objects.</p></div>
+Object methods cannot be inherited from other objects.</p></div>
 </div></div>
-<div class="paragraph"><p>The following example defines an object specific method <tt>bar</tt> on the
-instance <tt>c1</tt> of class <tt>C</tt>, and as well as the object specific method
-<tt>baz</tt> defined on the object <tt>o1</tt>. An object-specific method is defined
-simply by defining the method on an object.</p></div>
-<div class="paragraph"><p>Note that we can define a per-object method that shadows (redefines)
-for this object an intrinsic instance method.</p></div>
-<div class="paragraph" id="xmp-object-applicable1"><div class="title">Listing 29: Per-object Method</div><p></p></div>
+<div class="paragraph"><p>The following example defines an object method <code>bar</code> on the
+instance <code>c1</code> of class <code>C</code>, and as well as the object specific method
+<code>baz</code> defined on the object <code>o1</code>. An object method is defined
+via <code>object method</code>.</p></div>
+<div class="paragraph"><p>Note that we can define a object method that shadows (redefines)
+for this object methods provided from classes.</p></div>
+<div class="paragraph" id="xmp-object-applicable1"><div class="title">Listing 29: Object Method</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
 .nx             {color: #000000; font-weight: normal; font-style: normal; padding-left: 10px}
@@ -2452,8 +2482,8 @@
 </pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Class</span> <span class='nx-keyword'>create</span> C {
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} {<span class='nx-keyword'>return</span> 1}
   <span class='nx-keyword'>:create</span> c1 {
-     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} {<span class='nx-keyword'>return</span> 2}
-     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bar {} {<span class='nx-keyword'>return</span> 3}
+     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> foo {} {<span class='nx-keyword'>return</span> 2}
+     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {} {<span class='nx-keyword'>return</span> 3}
   }
 }
 
@@ -2465,7 +2495,7 @@
 
 <span class='nx-comment'># Method "baz" is an object specific method of "o1"
 </span><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o1 {
-  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> baz {} {<span class='nx-keyword'>return</span> 4}
+  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> baz {} {<span class='nx-keyword'>return</span> 4}
 }
 o1 baz</pre></td></tr></table></div></div>
 </div>
@@ -2474,17 +2504,17 @@
 <div class="exampleblock">
 <div class="content">
 <div class="paragraph"><p>A <strong>class method</strong> is a method defined on a class, which is only
-applicable to the class object itself. The class method is a
-per-object method of the class object.</p></div>
+applicable to the class object itself. The class method is actually
+an object method of the class object.</p></div>
 </div></div>
 <div class="paragraph"><p>In NX, all classes are objects. Classes are in NX special kind of
 objects that have e.g. the ability to create instances and to provide
 methods for the instances. Classes manage their instances. The general
 method set for classes is defined on the meta-classes (more about
 this later).</p></div>
-<div class="paragraph"><p>The following example defines a public class method <tt>bar</tt> on class
-<tt>C</tt>. The class method is specified by using the modifier <tt>class</tt> in
-front of <tt>method</tt> in the method definition command.</p></div>
+<div class="paragraph"><p>The following example defines a public class method <code>bar</code> on class
+<code>C</code>. The class method is specified by using the modifier <code>object</code> in
+front of <code>method</code> in the method definition command.</p></div>
 <div class="paragraph" id="xmp-object-applicable2"><div class="title">Listing 30: Class Methods</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -2527,7 +2557,7 @@
 </span>  <span class='nx-comment'># Define a class method "bar" and an instance
 </span>  <span class='nx-comment'># method "foo"
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>class</span> <span class='nx-keyword'>method</span> bar {} {<span class='nx-keyword'>return</span> 2}
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {} {<span class='nx-keyword'>return</span> 2}
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} {<span class='nx-keyword'>return</span> 1}
 
   <span class='nx-comment'>#
@@ -2553,7 +2583,7 @@
 </div>
 <div class="sect2">
 <h3 id="_ensemble_methods">3.5. Ensemble Methods</h3>
-<div class="paragraph"><p>NX provides "ensemble methods" as a means to structure the method name
+<div class="paragraph"><p>NX provides <em>ensemble methods</em> as a means to structure the method name
 space and to group related methods. Ensemble methods are similar in
 concept to Tcl&#8217;s ensemble commands.</p></div>
 <div class="exampleblock">
@@ -2567,7 +2597,7 @@
 and they are extensible in various ways. It is possible to add
 sub-methods at any time to existing ensembles. Furthermore, it is
 possible to extend ensemble methods via mixin classes.</p></div>
-<div class="paragraph"><p>The following example defines an ensemble method for <tt>string</tt>. An
+<div class="paragraph"><p>The following example defines an ensemble method for <code>string</code>. An
 ensemble method is defined when the provide method name contains a
 space.</p></div>
 <div class="paragraph" id="xmp-ensemble-methods"><div class="title">Listing 31: Ensemble Method</div><p></p></div>
@@ -2604,8 +2634,8 @@
     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> <span class='nx-string'>"string length"</span>  {x} {....}
     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> <span class='nx-string'>"string tolower"</span> {x} {...}
     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> <span class='nx-string'>"string info"</span> {x} {...}
-    ...
-    <span class='nx-keyword'>:create</span> c1
+    <span class='nx-comment'>#...
+</span>    <span class='nx-keyword'>:create</span> c1
 }
 
 <span class='nx-comment'># Invoke the ensemble method
@@ -2617,7 +2647,7 @@
 following order:</p></div>
 Per-object Mixins -> Per-class Mixins -> Object -> Intrinsic Class Hierarchy
 <div class="paragraph"><p>In the case, no mixins are involved, first the object is searched for
-a per-object method with the given name, and then the class hierarchy
+an object method with the given name, and then the class hierarchy
 of the object. The method can be defined multiple times on the search
 path, so some of these method definitions might be <em>shadowed</em> by the
 more specific definitions.</p></div>
@@ -2662,7 +2692,7 @@
   <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} { <span class='nx-keyword'>return</span> <span class='nx-string'>"D foo: [next]"</span>}
 
    <span class='nx-keyword'>:create</span> d1 {
-     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {} { <span class='nx-keyword'>return</span> <span class='nx-string'>"d1 foo: [next]"</span>}
+     <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> foo {} { <span class='nx-keyword'>return</span> <span class='nx-string'>"d1 foo: [next]"</span>}
    }
 }
 
@@ -2674,18 +2704,19 @@
 </span>d1 <span class='nx-keyword'>info</span> precedence
 <span class='nx-comment'># result: "::D ::C ::nx::Object"</span></pre></td></tr></table></div></div>
 <div class="paragraph"><p>Consider the example in
-<tt>foo</tt> is invoked on object <tt>d1</tt>, the per-object method has the highest
-precedence and is therefore invoked. The per-object methods shadows
-the same-named methods in the class hierarchy, namely the method <tt>foo</tt>
-of class <tt>D</tt> and the method <tt>foo</tt> of class <tt>C</tt>. The shadowed methods
-can be still invoked, either via the primitive <tt>next</tt> or via method
+<a href="#xmp-method-resolution">Listing 32</a>. When the method
+<code>foo</code> is invoked on object <code>d1</code>, the object method has the highest
+precedence and is therefore invoked. The object methods shadows
+the same-named methods in the class hierarchy, namely the method <code>foo</code>
+of class <code>D</code> and the method <code>foo</code> of class <code>C</code>. The shadowed methods
+can be still invoked, either via the primitive <code>next</code> or via method
 handles (we used already method handles in the section about method
-aliases). In the example above, <tt>next</tt> calls the shadowed method and
+aliases). In the example above, <code>next</code> calls the shadowed method and
 add their results to the results of every method. So, the final result
-contains parts from <tt>d1</tt>, <tt>D</tt> and <tt>C</tt>. Note, that the topmost <tt>next</tt>
-in method <tt>foo</tt> of class <tt>C</tt> shadows no method <tt>foo</tt> and simply
+contains parts from <code>d1</code>, <code>D</code> and <code>C</code>. Note, that the topmost <code>next</code>
+in method <code>foo</code> of class <code>C</code> shadows no method <code>foo</code> and simply
 returns empty (and not an error message).</p></div>
-<div class="paragraph"><p>The introspection method <tt>info precedence</tt> provides information about
+<div class="paragraph"><p>The introspection method <code>info precedence</code> provides information about
 the order, in which classes processed during method resolution.</p></div>
 <div class="paragraph" id="xmp-method-resolution2"><div class="title">Listing 33: Method Resolution with Mixin Classes</div><p></p></div>
 <div class="listingblock">
@@ -2734,7 +2765,7 @@
 </span><span class='nx-comment'># "d1" is created based on the definitions of the last example
 </span><span class='nx-comment'>#
 </span><span class='nx-comment'># Add the methods from "M1" as per-object mixin to "d1"
-</span>d1 <span class='nx-keyword'>mixin</span> M1
+</span>d1 <span class='nx-keyword'>object</span> <span class='nx-keyword'>mixin</span> M1
 
 <span class='nx-comment'>#
 </span><span class='nx-comment'># Add the methods from "M2" as per-class mixin to class "C"
@@ -2747,11 +2778,12 @@
 <span class='nx-comment'># Query the precedence order from NX via introspection
 </span>d1 <span class='nx-keyword'>info</span> precedence
 <span class='nx-comment'># result: "::M1 ::M2 ::D ::C ::nx::Object"</span></pre></td></tr></table></div></div>
-<div class="paragraph"><p>an extension of the previous example. We define here two additional
-classes <tt>M1</tt> and <tt>M2</tt> which are used as per-object and per-class
-mixins.  Both classes define the method <tt>foo</tt>, these methods shadow
+<div class="paragraph"><p>The example in <a href="#xmp-method-resolution2">Listing 33</a> is
+an extension of the previous example. We define here two additional
+classes <code>M1</code> and <code>M2</code> which are used as per-object and per-class
+mixins.  Both classes define the method <code>foo</code>, these methods shadow
 the definitions of the intrinsic class hierarchy. Therefore an
-invocation of <tt>foo</tt> on object <tt>d1</tt> causes first an invocation of
+invocation of <code>foo</code> on object <code>d1</code> causes first an invocation of
 method in the per-object mixin.</p></div>
 <div class="paragraph" id="xmp-method-resolution3"><div class="title">Listing 34: Method Invocation Flags</div><p></p></div>
 <div class="listingblock">
@@ -2785,10 +2817,10 @@
 </span><span class='nx-comment'># "d1" is created based on the definitions of the last two examples,
 </span><span class='nx-comment'># the mixins "M1" and "M2" are registered.
 </span><span class='nx-comment'>#
-</span><span class='nx-comment'># Define a public per-object method "bar", which calls the method
+</span><span class='nx-comment'># Define a public object method "bar", which calls the method
 </span><span class='nx-comment'># "foo" which various invocation options:
 </span><span class='nx-comment'>#
-</span>d1 <span class='nx-keyword'>public</span> <span class='nx-keyword'>method</span> bar {} {
+</span>d1 <span class='nx-keyword'>public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {} {
    <span class='nx-keyword'>puts</span> [:foo]
    <span class='nx-keyword'>puts</span> [: -local foo]
    <span class='nx-keyword'>puts</span> [: -intrinsic foo]
@@ -2797,43 +2829,43 @@
 
 <span class='nx-comment'># Invoke the method "bar"
 </span>d1 bar</pre></td></tr></table></div></div>
-<div class="paragraph"><p>In the first line of the body of method <tt>bar</tt>, the method <tt>foo</tt> is
+<div class="paragraph"><p>In the first line of the body of method <code>bar</code>, the method <code>foo</code> is
 called as usual with an implicit receiver, which defaults to the
-current object (therefore, the call is equivalent to <tt>d1 foo</tt>). The
+current object (therefore, the call is equivalent to <code>d1 foo</code>). The
 next three calls show how to provide flags that influence the method
 resolution. The flags can be provided between the colon and the method
 name. These flags are used rather seldomly but can be helpful in some
 situations.</p></div>
-<div class="paragraph"><p>The invocation flag <tt>-local</tt> means that the method has to be resolved
+<div class="paragraph"><p>The invocation flag <code>-local</code> means that the method has to be resolved
 from the same place, where the current method is defined. Since the
-current method is defined as a per-object method, <tt>foo</tt> is resolved as
-a per-object method. The effect is that the mixin definitions are
-ignored. The invocation flag <tt>-local</tt> was already introduced int the
+current method is defined as a object method, <code>foo</code> is resolved as
+a object method. The effect is that the mixin definitions are
+ignored. The invocation flag <code>-local</code> was already introduced int the
 section about method protection, where it was used to call <em>private</em>
 methods.</p></div>
-<div class="paragraph"><p>The invocation flag <tt>-intrinsic</tt> means that the method has to be resolved
+<div class="paragraph"><p>The invocation flag <code>-intrinsic</code> means that the method has to be resolved
 from the intrinsic definitions, meaning simply without mixins. The
-effect is here the same as with the invocation flag <tt>-local</tt>.</p></div>
-<div class="paragraph"><p>The invocation flag <tt>-system</tt> means that the method has to be resolved
+effect is here the same as with the invocation flag <code>-local</code>.</p></div>
+<div class="paragraph"><p>The invocation flag <code>-system</code> means that the method has to be resolved
 from basic - typically predefined - classes of the object system. This
 can be useful, when script overloads system methods, but still want to
 call the shadowed methods from the base classes. In our case, we have
-no definitions of <tt>foo</tt> on the base clases, therefore an error message
+no definitions of <code>foo</code> on the base clases, therefore an error message
 is returned.</p></div>
-<div class="paragraph"><p></p></div>
+<div class="paragraph"><p>The output of <a href="#xmp-method-resolution3">Listing 34</a> is:</p></div>
 <div class="listingblock">
 <div class="content">
-<pre><tt>   M1 foo: M2 foo: d1 foo: D foo: C foo:
+<pre><code>   M1 foo: M2 foo: d1 foo: D foo: C foo:
    d1 foo: D foo: C foo:
    d1 foo: D foo: C foo:
-   ::d1: unable to dispatch method 'foo'</tt></pre>
+   ::d1: unable to dispatch method 'foo'</code></pre>
 </div></div>
 </div>
 <div class="sect2">
 <h3 id="_parameters">3.7. Parameters</h3>
 <div class="paragraph"><p>NX provides a generalized mechanism for passing values to either
 methods (we refer to these as <em>method parameters</em>) or to objects
-(these are called <em>object parameters</em>). Both kind of parameters
+(these are called <em>configure parameters</em>). Both kind of parameters
 might have different features, such as:</p></div>
 <div class="ulist"><ul>
 <li>
@@ -2863,7 +2895,7 @@
 </li>
 </ul></div>
 <div class="paragraph"><p>TODO: complete list above and provide a short summary of the section</p></div>
-<div class="paragraph"><p>Before we discuss method and object parameters in more detail, we
+<div class="paragraph"><p>Before we discuss method and configure parameters in more detail, we
 describe the parameter features in the subsequent sections based on
 method parameters.</p></div>
 <div class="sect3">
@@ -2930,22 +2962,22 @@
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Method foo has positional parameters:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {x y} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> foo {x y} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y=$y"</span>
   }
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Method bar has non-positional parameters:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bar {-x -y} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {-x -y} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y=$y"</span>
   }
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Method baz has non-positional and
 </span>  <span class='nx-comment'># positional parameters:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> baz {-x -y a} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> baz {-x -y a} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x? [info exists x] y? [info exists y] a=$a"</span>
   }
 }
@@ -2962,31 +2994,31 @@
 o1 baz 200
 o1 baz -- -y</pre></td></tr></table></div></div>
 <div class="paragraph"><p>Consider the example in <a href="#xmp-posnonpos">Listing 35</a>. The method
-<tt>foo</tt> has the argument list <tt>x y</tt>. This means that the first argument
-is passed in an invocation like <tt>o1 foo 1 2</tt> to <tt>x</tt> (here, the value
-<tt>1</tt>), and the second argument is passed to <tt>y</tt> (here the value <tt>2</tt>).
-Method <tt>bar</tt> has in contrary just with non-positional arguments. Here
+<code>foo</code> has the argument list <code>x y</code>. This means that the first argument
+is passed in an invocation like <code>o1 foo 1 2</code> to <code>x</code> (here, the value
+<code>1</code>), and the second argument is passed to <code>y</code> (here the value <code>2</code>).
+Method <code>bar</code> has in contrary just with non-positional arguments. Here
 we pass the names of the parameter together with the values. In the
-invocation <tt>o1 bar -y 3 -x 1</tt> the names of the parameters are prefixed
+invocation <code>o1 bar -y 3 -x 1</code> the names of the parameters are prefixed
 with a dash ("-"). No matter whether in which order we write the
 non-positional parameters in the invocation (see line 30 and 31 in
-<a href="#xmp-posnonpos">Listing 35</a>) in both cases the variables <tt>x</tt>
-and <tt>y</tt> in the body of the method <tt>bar</tt> get the same values assigned
-(<tt>x</tt> becomes <tt>1</tt>, <tt>y</tt> becomes <tt>3</tt>).</p></div>
+<a href="#xmp-posnonpos">Listing 35</a>) in both cases the variables <code>x</code>
+and <code>y</code> in the body of the method <code>bar</code> get the same values assigned
+(<code>x</code> becomes <code>1</code>, <code>y</code> becomes <code>3</code>).</p></div>
 <div class="paragraph"><p>It is certainly possible to combine positional and non-positional
-arguments. Method <tt>baz</tt> provides two non-positional parameter (<tt>-y</tt>
-and <tt>-y</tt>) and one positional parameter (namely <tt>a</tt>). The invocation in
-line 34 passes the value of <tt>1</tt> to <tt>x</tt> and the value of <tt>100</tt> to <tt>a</tt>.
-There is no value passed to <tt>y</tt>, therefore value of <tt>y</tt> will be
-undefined in the body of <tt>baz</tt>, <tt>info exists y</tt> checks for the
-existence of the variable <tt>y</tt> and returns <tt>0</tt>.</p></div>
+arguments. Method <code>baz</code> provides two non-positional parameter (<code>-y</code>
+and <code>-y</code>) and one positional parameter (namely <code>a</code>). The invocation in
+line 34 passes the value of <code>1</code> to <code>x</code> and the value of <code>100</code> to <code>a</code>.
+There is no value passed to <code>y</code>, therefore value of <code>y</code> will be
+undefined in the body of <code>baz</code>, <code>info exists y</code> checks for the
+existence of the variable <code>y</code> and returns <code>0</code>.</p></div>
 <div class="paragraph"><p>The invocation in line 35 passes only a value to the positional
 parameter. A more tricky case is in line 36, where we want to pass
-<tt>-y</tt> as a value to the positional parameter <tt>a</tt>. The case is more
-tricky since syntactically the argument parser might consider <tt>-y</tt> as
-the name of one of the non-positional parameter. Therefore we use <tt>--</tt>
+<code>-y</code> as a value to the positional parameter <code>a</code>. The case is more
+tricky since syntactically the argument parser might consider <code>-y</code> as
+the name of one of the non-positional parameter. Therefore we use <code>--</code>
 (double dash) to indicate the end of the block of the non-positional
-parameters and therefore the value of <tt>-y</tt> is passed to <tt>a</tt>.</p></div>
+parameters and therefore the value of <code>-y</code> is passed to <code>a</code>.</p></div>
 </div>
 <div class="sect3">
 <h4 id="_optional_and_required_parameters">3.7.2. Optional and Required Parameters</h4>
@@ -3033,40 +3065,40 @@
 </span>  <span class='nx-comment'># Method foo has one required and one optional
 </span>  <span class='nx-comment'># positional parameter:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {x:required y:optional} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> foo {x:required y:optional} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y? [info exists y]"</span>
   }
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Method bar has one required and one optional
 </span>  <span class='nx-comment'># non-positional parameter:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bar {-x:required -y:optional} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {-x:required -y:optional} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y? [info exists y]"</span>
   }
 }
 
 <span class='nx-comment'># invoke foo (one optional positional parameter is missing)
 </span>o2 foo 1</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The example in <a href="#xmp-optional-req">Listing 36</a> defined method <tt>foo</tt>
+<div class="paragraph"><p>The example in <a href="#xmp-optional-req">Listing 36</a> defined method <code>foo</code>
 with one required and one optional positional parameter. For this
-purpose we use the parameter options <tt>required</tt> and <tt>optional</tt>. The
+purpose we use the parameter options <code>required</code> and <code>optional</code>. The
 parameter options are separated from the parameter name by a colon. If
 there are multiple parameter options, these are separated by commas
 (we show this in later examples).</p></div>
-<div class="paragraph"><p>The parameter definition <tt>x:required</tt> for method <tt>foo</tt> is equivalent
-to <tt>x</tt> without any parameter options (see e.g. previous example),
+<div class="paragraph"><p>The parameter definition <code>x:required</code> for method <code>foo</code> is equivalent
+to <code>x</code> without any parameter options (see e.g. previous example),
 since positional parameters are per default required. The invocation
 in line 21 of <a href="#xmp-optional-req">Listing 36</a> will lead to an
-undefined variable <tt>y</tt> in method <tt>foo</tt>, because no value us passed to
+undefined variable <code>y</code> in method <code>foo</code>, because no value us passed to
 the optional parameter. Note that only trailing positional parameters might be
-optional. If we would call method <tt>foo</tt> of <a href="#xmp-posnonpos">Listing 35</a> with only one argument, the system would raise an
+optional. If we would call method <code>foo</code> of <a href="#xmp-posnonpos">Listing 35</a> with only one argument, the system would raise an
 exception.</p></div>
-<div class="paragraph"><p>Similarly, we define method <tt>bar</tt> in <a href="#xmp-optional-req">Listing 36</a> with one required and one optional non-positional
-parameter. The parameter definition <tt>-y:optional</tt> is equivalent to
-<tt>-y</tt>, since non-positional parameter are per default optional.
-However, the non-positional parameter <tt>-x:required</tt> is required. If we
-invoke <tt>bar</tt> without it, the system will raise an exception.</p></div>
+<div class="paragraph"><p>Similarly, we define method <code>bar</code> in <a href="#xmp-optional-req">Listing 36</a> with one required and one optional non-positional
+parameter. The parameter definition <code>-y:optional</code> is equivalent to
+<code>-y</code>, since non-positional parameter are per default optional.
+However, the non-positional parameter <code>-x:required</code> is required. If we
+invoke <code>bar</code> without it, the system will raise an exception.</p></div>
 </div>
 <div class="sect3">
 <h4 id="_default_values_for_parameters">3.7.3. Default Values for Parameters</h4>
@@ -3110,24 +3142,24 @@
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Positional parameter with default value:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {x:required {y 101}} {
-    <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y? [info exists y]"</span>
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> foo {{x 1} {y 2}} {
+    <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y=$y"</span>
   }
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Non-positional parameter with default value:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bar {{-x 10} {-y 20}} {
-    <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y? [info exists y]"</span>
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {{-x 10} {-y 20}} {
+    <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y=$y"</span>
   }
 }
 
 <span class='nx-comment'># use default values
 </span>o3 foo
 o3 bar</pre></td></tr></table></div></div>
-<div class="paragraph"><p>In order to define a default value, the parameter specification must
-be of the form of a 2 element list, where the second argument is the
-default value. See for an example in
+<div class="paragraph"><p>In order to define a default value for a parameter, the parameter
+specification must be of the form of a 2 element list, where the
+second argument is the default value. See for an example in
 <a href="#xmp-default-value">Listing 37</a>.</p></div>
 </div>
 <div class="sect3">
@@ -3145,7 +3177,7 @@
 extended on the scripting level. The built-in checkers are either the
 native checkers provided directly by the Next Scripting Framework (the
 most efficient checkers) or the value checkers provided by Tcl through
-<tt>string is &#8230;</tt>. The built-in checkers have as well the advantage that
+<code>string is &#8230;</code>. The built-in checkers have as well the advantage that
 they can be used also at any time during bootstrap of an object
 system, at a time, when e.g. no objects or methods are defined. The
 same checkers are used as well for all C-implemented primitives of NX
@@ -3159,7 +3191,7 @@
 <div class="paragraph"><p></p></div>
 <div class="paragraph"><p><a href="#img-value-checkers">Figure 38</a> shows the built-in
 general applicable value checkers available in NX, which can be used
-for all method and object parameters. In the next step, we show how to
+for all method and configure parameters. In the next step, we show how to
 use these value-checkers for checking permissible values for method
 parameters. Then we will show, how to provide more detailed value
 constraints.</p></div>
@@ -3194,34 +3226,36 @@
  17
  18
  19
+ 20
 </pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>nx::Object</span> <span class='nx-keyword'>create</span> o4 {
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Positional parameter with value constraints:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {x:integer o:object,optional} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> foo {x:integer o<span class='nx-keyword'>:object</span>,optional} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x o? [info exists o]"</span>
   }
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Non-positional parameter with value constraints:
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bar {{-x:integer 10} {-verbose:boolean false}} {
-    <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x y=$y"</span>
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {{-x:integer 10} {-verbose:boolean false}} {
+    <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x verbose=$verbose"</span>
   }
 }
 
-<span class='nx-comment'># The following invocation raises an exception
+<span class='nx-comment'># The following invocation raises an exception, since the
+</span><span class='nx-comment'># value "a" for parameter "x" is not an integer
 </span>o4 foo a</pre></td></tr></table></div></div>
 <div class="paragraph"><p>Value contraints are specified as parameter options in the parameter
-specifications. The parameter specification <tt>x:integer</tt> defines <tt>x</tt> as
+specifications. The parameter specification <code>x:integer</code> defines <code>x</code> as
 a required positional parmeter which value is constraint to an
-integer. The parameter specification <tt>o:object,optional</tt> shows how to
-combine multiple parameter options. The parameter <tt>o</tt> is an optional
+integer. The parameter specification <code>o:object,optional</code> shows how to
+combine multiple parameter options. The parameter <code>o</code> is an optional
 positional parameter, its value must be an object (see
 <a href="#xmp-value-check">Listing 39</a>). Value constraints are
 specified exactly the same way for non-positional parameters (see
-method <tt>bar</tt> in <a href="#xmp-value-check">Listing 39</a>).</p></div>
+method <code>bar</code> in <a href="#xmp-value-check">Listing 39</a>).</p></div>
 <div class="paragraph" id="xmp-check-parameterized"><div class="title">Listing 40: Parameterized Value Constraints</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -3272,9 +3306,9 @@
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Parameterized value constraints
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> work {
-     -person:object,type=Person
-     -project:object,type=Project
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> work {
+     -person<span class='nx-keyword'>:object</span>,type=Person
+     -project<span class='nx-keyword'>:object</span>,type=Project
    } {
     <span class='nx-comment'># ...
 </span>  }
@@ -3290,27 +3324,27 @@
 </span><span class='nx-comment'># Use method with value constraints
 </span><span class='nx-comment'>#
 </span>o5 work -person gustaf -project nx</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The native checkers <tt>object</tt>, <tt>class</tt>, <tt>metaclass</tt> and <tt>baseclass</tt> can
-be further specialized with the parameter option <tt>type</tt> to restrict
+<div class="paragraph"><p>The native checkers <code>object</code>, <code>class</code>, <code>metaclass</code> and <code>baseclass</code> can
+be further specialized with the parameter option <code>type</code> to restrict
 the permissible values to instances of certain classes. We can use for
-example the native value constraint <tt>object</tt> either for testing
+example the native value constraint <code>object</code> either for testing
 whether an argument is some object (without further constraints, as in
-<a href="#xmp-default-value">Listing 37</a>, method <tt>foo</tt>), or we can
+<a href="#xmp-default-value">Listing 37</a>, method <code>foo</code>), or we can
 constrain the value further to some type (direct or indirect instance
-of a class). This is shown by method <tt>work</tt> in
+of a class). This is shown by method <code>work</code> in
 <a href="#xmp-check-parameterized">Listing 40</a> which requires
-the parameter <tt>-person</tt> to be an instance of class <tt>Person</tt> and the
-parameter <tt>-project</tt> to be an instance of class <tt>Project</tt>.</p></div>
+the parameter <code>-person</code> to be an instance of class <code>Person</code> and the
+parameter <code>-project</code> to be an instance of class <code>Project</code>.</p></div>
 </div>
 <div class="sect4">
 <h5 id="_scripted_value_constraints">Scripted Value Constraints</h5>
 <div class="paragraph"><p>The set of predefined value checkers can be extended by application
 programs via defining methods following certain conventions. The user
-defined value checkers are defined as methods of the class <tt>nx::Slot</tt>
+defined value checkers are defined as methods of the class <code>nx::Slot</code>
 or of one of its subclasses or instances. We will address such cases
 in the next sections. In the following example we define two new
-value checkers on class <tt>nx::Slot</tt>. The first value checker is called
-<tt>groupsize</tt>, the second one is called <tt>choice</tt>.</p></div>
+value checkers on class <code>nx::Slot</code>. The first value checker is called
+<code>groupsize</code>, the second one is called <code>choice</code>.</p></div>
 <div class="paragraph" id="xmp-user-types"><div class="title">Listing 41: Scripted Value Checker for Method Parameters</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -3363,6 +3397,9 @@
  38
  39
  40
+ 41
+ 42
+ 43
 </pre></td><td class='nx-body'><pre class='nx'><span class='nx-comment'>#
 </span><span class='nx-comment'># Value checker named "groupsize"
 </span><span class='nx-comment'>#
@@ -3396,32 +3433,35 @@
 
 D <span class='nx-keyword'>create</span> d1
 
-<span class='nx-comment'># testing "groupsize"
+<span class='nx-comment'># testing "groupsize";
+</span><span class='nx-comment'># the second call (with value 10) will raise an exception:
 </span>d1 foo 2
 d1 foo 10
 
 <span class='nx-comment'># testing "choice"
+</span><span class='nx-comment'># the second call (with value pink for parameter a)
+</span><span class='nx-comment'># will raise an exception:
 </span>d1 bar green good
 d1 bar pink bad</pre></td></tr></table></div></div>
-<div class="paragraph"><p>In order to define a checker <tt>groupsize</tt> a method of the name
-<tt>type=groupsize</tt> is defined. This method receives two arguments,
-<tt>name</tt> and <tt>value</tt>. The first argument is the name of the parameter
+<div class="paragraph"><p>In order to define a checker <code>groupsize</code> a method of the name
+<code>type=groupsize</code> is defined. This method receives two arguments,
+<code>name</code> and <code>value</code>. The first argument is the name of the parameter
 (mostly used for the error message) and the second parameter is
 provided value. The value checker simply tests whether the provided
 value is between 1 and 3 and raises an exception if this is not the
 case (invocation in line 36 in <a href="#xmp-user-types">Listing 41</a>).</p></div>
-<div class="paragraph"><p>The checker <tt>groupsize</tt> has the permissible values defined in its
+<div class="paragraph"><p>The checker <code>groupsize</code> has the permissible values defined in its
 method&#8217;s body. It is as well possible to define more generic checkers
 that can be parameterized. For this parameterization, one can pass an
-argument to the checker method (last argument). The checker <tt>choice</tt>
+argument to the checker method (last argument). The checker <code>choice</code>
 can be used for restricting the values to a set of predefined
 constants. This set is defined in the parameter specification. The
-parameter <tt>a</tt> of method <tt>bar</tt> in <a href="#xmp-user-types">Listing 41</a>
-is restricted to the values <tt>red</tt>, <tt>yellow</tt> or <tt>green</tt>, and the
-parameter <tt>b</tt> is restricted to <tt>good</tt> or <tt>bad</tt>. Note that the syntax
+parameter <code>a</code> of method <code>bar</code> in <a href="#xmp-user-types">Listing 41</a>
+is restricted to the values <code>red</code>, <code>yellow</code> or <code>green</code>, and the
+parameter <code>b</code> is restricted to <code>good</code> or <code>bad</code>. Note that the syntax
 of the permissible values is solely defined by the definition of the
 value checker in lines 13 to 17. The invocation in line 39 will be ok,
-the invocation in line 40 will raise an exception, since <tt>pink</tt> is not
+the invocation in line 40 will raise an exception, since <code>pink</code> is not
 allowed.</p></div>
 <div class="paragraph"><p>If the same checks are used in many places in the program,
 defining names for the value checker will be the better choice since
@@ -3437,15 +3477,15 @@
 single or multiple values.</p></div>
 </div></div>
 <div class="paragraph"><p>A multiplicity specification has a lower and an upper bound. A lower
-bound of <tt>0</tt> means that the value might be empty. A lower bound of <tt>1</tt>
+bound of <code>0</code> means that the value might be empty. A lower bound of <code>1</code>
 means that the parameter needs at least one value. The upper bound
-might be <tt>1</tt> or <tt>n</tt> (or synonymously <tt>*</tt>). While the upper bound of
-<tt>1</tt> states that at most one value has to be passed, the upper bound of
-<tt>n</tt> says that multiple values are permitted. Other kinds of
+might be <code>1</code> or <code>n</code> (or synonymously <code>*</code>). While the upper bound of
+<code>1</code> states that at most one value has to be passed, the upper bound of
+<code>n</code> says that multiple values are permitted. Other kinds of
 multiplicity are currently not allowed.</p></div>
 <div class="paragraph"><p>The multiplicity is written as parameter option in the parameter
 specification in the form <em>lower-bound</em>..<em>upper-bound</em>. If no
-multiplicity is defined the default multiplicity is <tt>1..1</tt>, which
+multiplicity is defined the default multiplicity is <code>1..1</code>, which
 means: provide exactly one (atomic) value (this was the case in the
 previous examples).</p></div>
 <div class="paragraph" id="xmp-multiplicity"><div class="title">Listing 42: Method Parameters with Explicit Multiplicity</div><p></p></div>
@@ -3492,33 +3532,33 @@
 </span>  <span class='nx-comment'># Positional parameter with an possibly empty
 </span>  <span class='nx-comment'># single value
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> foo {x:integer,0..1} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> foo {x:integer,0..1} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x"</span>
   }
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Positional parameter with an possibly empty
 </span>  <span class='nx-comment'># list of values value
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> bar {x:integer,0..n} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> bar {x:integer,0..n} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x"</span>
   }
 
   <span class='nx-comment'>#
 </span>  <span class='nx-comment'># Positional parameter with a non-empty
 </span>  <span class='nx-comment'># list of values
 </span>  <span class='nx-comment'>#
-</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>method</span> baz {x:integer,1..n} {
+</span>  <span class='nx-keyword'>:public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> baz {x:integer,1..n} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"x=$x"</span>
   }
 }</pre></td></tr></table></div></div>
 <div class="paragraph"><p><a href="#xmp-multiplicity">Listing 42</a> contains three examples for
 positional parameters with different multiplicities. Multiplicity is
 often combined with value constraints. A parameter specification of
-the form <tt>x:integer,0..n</tt> means that the parameter <tt>x</tt> receives a list
+the form <code>x:integer,0..n</code> means that the parameter <code>x</code> receives a list
 of integers, which might be empty. Note that the value constraints are
 applied to every single element of the list.</p></div>
-<div class="paragraph"><p>The parameter specification <tt>x:integer,0..1</tt> means that <tt>x</tt> might be
+<div class="paragraph"><p>The parameter specification <code>x:integer,0..1</code> means that <code>x</code> might be
 an integer or it might be empty. This is one style of specifying that
 no explicit value is passed for a certain parameter. Another style is
 to use required or optional parameters. NX does not enforce any
@@ -3545,7 +3585,7 @@
 <div class="paragraph"><p>&#8230;</p></div>
 </div>
 <div class="sect2">
-<h3 id="_details_on_method_and_object_parameters">4.3. Details on Method and Object Parameters</h3>
+<h3 id="_details_on_method_and_configure_parameters">4.3. Details on Method and Configure Parameters</h3>
 <div class="paragraph"><p>The parameter specifications are used in NX for the following
 purposes. They are used for</p></div>
 <div class="ulist"><ul>
@@ -3566,7 +3606,7 @@
 </li>
 </ul></div>
 <div class="paragraph"><p>We refer to the first two as method parameters and the last one as
-object parameters. The examples in the previous sections all parameter
+configure parameters. The examples in the previous sections all parameter
 specification were specifications of method parameters.</p></div>
 <div class="sidebarblock">
 <div class="content">
@@ -3578,18 +3618,17 @@
 and what kind of checks should be performed on these.</p></div>
 <div class="sidebarblock">
 <div class="content">
-<div class="paragraph"><p><strong>Object parameters</strong> are parameters that specify, with what values
-instance variables of objects are initialized and how these objects
-could be parameterized.</p></div>
+<div class="paragraph"><p><strong>Configure parameters</strong> are parameters that specify, how objects
+can be parameterized upon creation.</p></div>
 </div></div>
-<div class="paragraph"><p>Syntactically, object parameters and method parameters are the same,
+<div class="paragraph"><p>Syntactically, configure parameters and method parameters are the same,
 although there are certain differences (e.g. some parameter options
 are only applicable for objects parameters, the list of object
 parameters is computed dynamically from the class structures, object
 parameters are often used in combination with special setter methods,
 etc.).  Consider the following example, where we define the two
-application classes <tt>Person</tt> and <tt>Student</tt> with a few properties.</p></div>
-<div class="paragraph" id="xmp-object-parameters"><div class="title">Listing 43: Object Parameters</div><p></p></div>
+application classes <code>Person</code> and <code>Student</code> with a few properties.</p></div>
+<div class="paragraph" id="xmp-object-parameters"><div class="title">Listing 43: Configure Parameters</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
 .nx             {color: #000000; font-weight: normal; font-style: normal; padding-left: 10px}
@@ -3647,47 +3686,47 @@
 }
 
 <span class='nx-comment'>#
-</span><span class='nx-comment'># Create instances using object parameters
+</span><span class='nx-comment'># Create instances using configure parameters
 </span><span class='nx-comment'># for the initialization
 </span><span class='nx-comment'>#
 </span>Person <span class='nx-keyword'>create</span> p1 -name Bob
 Student <span class='nx-keyword'>create</span> s1 -name Susan -matnr 4711
 
-<span class='nx-comment'># Access property value via accessor method
-</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 name]"</span></pre></td></tr></table></div></div>
-<div class="paragraph"><p>The class <tt>Person</tt> has two properties <tt>name</tt> and <tt>birthday</tt>, where the
-property <tt>name</tt> is required, the property <tt>birthday</tt> is not. The
-class <tt>Student</tt> is a subclass of <tt>Person</tt> with the additional required
-property <tt>matnr</tt> and an optional property <tt>oncampus</tt> with the
-default value <tt>true</tt> (see <a href="#xmp-object-parameters">Listing 43</a>). The class diagram below visualizes these
+<span class='nx-comment'># Access property value via "cget" method
+</span><span class='nx-keyword'>puts</span> <span class='nx-string'>"The name of s1 is [s1 cget -name]"</span></pre></td></tr></table></div></div>
+<div class="paragraph"><p>The class <code>Person</code> has two properties <code>name</code> and <code>birthday</code>, where the
+property <code>name</code> is required, the property <code>birthday</code> is not. The
+class <code>Student</code> is a subclass of <code>Person</code> with the additional required
+property <code>matnr</code> and an optional property <code>oncampus</code> with the
+default value <code>true</code> (see <a href="#xmp-object-parameters">Listing 43</a>). The class diagram below visualizes these
 definitions.</p></div>
-<div class="imageblock" id="img-object-parameters" style="text-align:center;">
+<div class="imageblock" id="img-configure-parameters" style="text-align:center;">
 <div class="content">
-<img src="object-parameter.png" alt="object-parameter.png" />
+<img src="configure-parameter.png" alt="configure-parameter.png" />
 </div>
 <div class="title">Figure 44. System and Application Classes</div>
 </div>
 <div class="paragraph"><p></p></div>
-<div class="paragraph"><p>In NX, these definitions imply that instances of the class of <tt>Person</tt>
-have the properties <tt>name</tt> and <tt>birthday</tt> as <em>non-positional object
-parameters</em>.  Furthermore it implies that instances of <tt>Student</tt> will
-have the object parameters of <tt>Person</tt> augmented with the object
-parameters from <tt>Student</tt> (namely <tt>matnr</tt> and <tt>oncampus</tt>).  Based on
-these object parameters, we can create a <tt>Person</tt> named <tt>Bob</tt> and a
-<tt>Student</tt> named <tt>Susan</tt> with the matriculation number <tt>4711</tt> (see line
-23 and 24 in <a href="#xmp-object-parameters">Listing 43</a>). After the object <tt>s1</tt> is created it has the
-instance variables <tt>name</tt>, <tt>matnr</tt> and <tt>oncampus</tt> (the latter is
+<div class="paragraph"><p>In NX, these definitions imply that instances of the class of <code>Person</code>
+have the properties <code>name</code> and <code>birthday</code> as <em>non-positional object
+parameters</em>.  Furthermore it implies that instances of <code>Student</code> will
+have the configure parameters of <code>Person</code> augmented with the object
+parameters from <code>Student</code> (namely <code>matnr</code> and <code>oncampus</code>).  Based on
+these configure parameters, we can create a <code>Person</code> named <code>Bob</code> and a
+<code>Student</code> named <code>Susan</code> with the matriculation number <code>4711</code> (see line
+23 and 24 in &lt;&lt;xmp-object-parameters,
+instance variables <code>name</code>, <code>matnr</code> and <code>oncampus</code> (the latter is
 initialized with the default value).</p></div>
 <div class="sect3">
-<h4 id="_object_parameters_for_all_nx_objects">4.3.1. Object Parameters for all NX Objects</h4>
-<div class="paragraph"><p>The object parameters are not limited to the application defined
+<h4 id="_configure_parameters_available_for_all_nx_objects">4.3.1. Configure Parameters available for all NX Objects</h4>
+<div class="paragraph"><p>The configure parameters are not limited to the application defined
 properties, also NX provides some predefined definitions. Since
-<tt>Person</tt> is a subclass of <tt>nx::Object</tt> also the object parameters of
-<tt>nx::Object</tt> are inherited. In the introductory stack example, we used
-<tt>-mixin</tt> applied to an object to denote per-object mixins (see
-<a href="#xmp-using-class-safety">Listing 8</a>). Since <tt>mixin</tt>
-is defined as a parameter on <tt>nx::Object</tt> it can be used as an object
-parameter <tt>-mixin</tt> for all objects in NX. To put it in other words,
+<code>Person</code> is a subclass of <code>nx::Object</code> also the configure parameters of
+<code>nx::Object</code> are inherited. In the introductory stack example, we used
+<code>-mixin</code> applied to an object to denote per-object mixins (see
+<a href="#xmp-using-class-safety">Listing 8</a>). Since <code>mixin</code>
+is defined as a parameter on <code>nx::Object</code> it can be used as an object
+parameter <code>-mixin</code> for all objects in NX. To put it in other words,
 every object can be configured to have per-object mixins. If we would
 remove this definition, this feature would be removed as well.</p></div>
 <div class="paragraph"><p>As shown in the introductory examples, every object can be configured
@@ -3696,10 +3735,10 @@
 <a href="#xmp-object-stack">Listing 5</a> or
 <a href="#xmp-object-integer-stack">Listing 12</a>). The
 scripted block and its meaning are as well defined by the means of
-object parameters. However, this object parameter is positional (last
+configure parameters. However, this configure parameter is positional (last
 argument) and optional (it can be omitted). The following listing shows
-(simplified) the object parameters of <tt>Person p1</tt> and <tt>Student s1</tt>.</p></div>
-<div class="paragraph" id="xmp-object-parameter-list"><div class="title">Listing 45: Computed Actual Object Parameter (simplified)</div><p></p></div>
+(simplified) the configure parameters of <code>Person p1</code> and <code>Student s1</code>.</p></div>
+<div class="paragraph" id="xmp-object-parameter-list"><div class="title">Listing 45: Computed Actual Configure Parameter (simplified)</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
 .nx             {color: #000000; font-weight: normal; font-style: normal; padding-left: 10px}
@@ -3719,48 +3758,48 @@
   6
   7
   8
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> Person p1:
+</pre></td><td class='nx-body'><pre class='nx'>Configure parameter <span class='nx-keyword'>for</span> Person p1:
    -name:required -birthday ...
    -mixin:mixinreg,<span class='nx-keyword'>alias</span>,1..n -filter:filterreg,<span class='nx-keyword'>alias</span>,1..n _:initcmd,optional
 
-<span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> Student s1:
+Configure parameter <span class='nx-keyword'>for</span> Student s1:
    -matnr:required {-oncampus:boolean true}
    -name:required -birthday ...
    -mixin:mixinreg,<span class='nx-keyword'>alias</span>,1..n -filter:filterreg,<span class='nx-keyword'>alias</span>,1..n _:initcmd,optional</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The actual values can be obtained via introspection via <tt>Person info
-parameter definition</tt>. The object parameter types <tt>mixinreg</tt> and
-<tt>filterreg</tt> are for converting definitions of filters and mixins.  The
-object parameter type <tt>initcmd</tt> says that the content of this variable
+<div class="paragraph"><p>The actual values can be obtained via introspection via <code>Person info
+parameter definition</code>. The configure parameter types <code>mixinreg</code> and
+<code>filterreg</code> are for converting definitions of filters and mixins.  The
+configure parameter type <code>initcmd</code> says that the content of this variable
 will be executed in the context of the object being created (before
-the constructor <tt>init</tt> is called).  More about the object parameter
+the constructor <code>init</code> is called).  More about the configure parameter
 types later.</p></div>
 </div>
 <div class="sect3">
-<h4 id="_object_parameters_for_all_nx_classes">4.3.2. Object Parameters for all NX Classes</h4>
+<h4 id="_configure_parameters_available_for_all_nx_classes">4.3.2. Configure Parameters available for all NX Classes</h4>
 <div class="paragraph"><p>Since classes are certain kind of objects, classes are parameterized
 in the same way as objects. A typical parameter for a class definition
 is the relation of the class to its superclass.In our example, we have
-specified, that <tt>Student</tt> has <tt>Person</tt> as superclass via the
-non-positional object parameter <tt>-superclass</tt>. If no superclass is
+specified, that <code>Student</code> has <code>Person</code> as superclass via the
+non-positional configure parameter <code>-superclass</code>. If no superclass is
 specified for a class, the default superclass is
-<tt>nx::Object</tt>. Therefore <tt>nx::Object</tt> is the default value for the
-parameter <tt>superclass</tt>.</p></div>
-<div class="paragraph"><p>Another frequently used parameter for classes is <tt>-mixin</tt> to denote
+<code>nx::Object</code>. Therefore <code>nx::Object</code> is the default value for the
+parameter <code>superclass</code>.</p></div>
+<div class="paragraph"><p>Another frequently used parameter for classes is <code>-mixin</code> to denote
 per-class mixins (see e.g. the introductory Stack example in
 <a href="#xmp-class-safestack">Listing 10</a>), which is defined in
 the same way.</p></div>
-<div class="paragraph"><p>Since <tt>Student</tt> is an instance of the meta-class <tt>nx::Class</tt> it
-inherits the object parameters from <tt>nx::Class</tt> (see class diagram
-<a href="#img-object-parameters">Figure 44</a>). Therefore, one can
-use e.g. <tt>-superclass</tt> in the definition of classes.</p></div>
-<div class="paragraph"><p>Since <tt>nx::Class</tt> is a subclass of <tt>nx::Object</tt>, the meta-class
-<tt>nx::Class</tt> inherits the parameter definitions from the most general
-class <tt>nx::Object</tt>. Therefore, every class might as well be configured
+<div class="paragraph"><p>Since <code>Student</code> is an instance of the meta-class <code>nx::Class</code> it
+inherits the configure parameters from <code>nx::Class</code> (see class diagram
+<a href="#img-configure-parameters">Figure 44</a>). Therefore, one can
+use e.g. <code>-superclass</code> in the definition of classes.</p></div>
+<div class="paragraph"><p>Since <code>nx::Class</code> is a subclass of <code>nx::Object</code>, the meta-class
+<code>nx::Class</code> inherits the parameter definitions from the most general
+class <code>nx::Object</code>. Therefore, every class might as well be configured
 with a scripted initialization block the same way as objects can be
 configured. We used actually this scripted initialization block in
 most examples for defining the methods of the class. The following
-listing shows (simplified) the parameters applicable for <tt>Class
-Student</tt>.</p></div>
+listing shows (simplified) the parameters applicable for <code>Class
+Student</code>.</p></div>
 <div class="paragraph" id="xmp-class-parameter-list"><div class="title">Listing 46: Computed Parameters for a Class (simplified)</div><p></p></div>
 <div class="listingblock">
 <div class="content"><style type='text/css'>
@@ -3776,23 +3815,23 @@
 <table class='nx'><tr><td class='nx-linenr'><pre>  1
   2
   3
-</pre></td><td class='nx-body'><pre class='nx'><span class='nx-keyword'>Object</span> parameter <span class='nx-keyword'>for</span> <span class='nx-keyword'>Class</span> Student:
+</pre></td><td class='nx-body'><pre class='nx'>Configure parameter <span class='nx-keyword'>for</span> <span class='nx-keyword'>Class</span> Student:
    -mixin:mixinreg,<span class='nx-keyword'>alias</span>,1..n -filter:filterreg,<span class='nx-keyword'>alias</span>,1..n ...
    {-superclass<span class='nx-keyword'>:class</span>,<span class='nx-keyword'>alias</span>,1..n ::nx::Object} ...</pre></td></tr></table></div></div>
-<div class="paragraph"><p>The actual values can be obtained via introspection via <tt>nx::Class info
-parameter definition</tt>.</p></div>
+<div class="paragraph"><p>The actual values can be obtained via introspection via <code>nx::Class info
+parameter definition</code>.</p></div>
 </div>
 <div class="sect3">
 <h4 id="_user_defined_parameter_types">4.3.3. User defined Parameter Types</h4>
-<div class="paragraph"><p>More detailed definition of the object parameter types comes here.</p></div>
+<div class="paragraph"><p>More detailed definition of the configure parameter types comes here.</p></div>
 </div>
 <div class="sect3">
 <h4 id="_slot_classes_and_slot_objects">4.3.4. Slot Classes and Slot Objects</h4>
 <div class="paragraph"><p>In one of the previous sections, we defined scripted (application
-defined) checker methods on a class named <tt>nx::Slot</tt>.  In general NX
+defined) checker methods on a class named <code>nx::Slot</code>.  In general NX
 offers the possibility to define value checkers not only for all
 usages of parameters but as well differently for method parameters or
-object parameters</p></div>
+configure parameters</p></div>
 <div class="imageblock" id="img-slots" style="text-align:center;">
 <div class="content">
 <img src="slots.png" alt="slots.png" />
@@ -3843,8 +3882,10 @@
 <div class="sect1">
 <h2 id="_miscellaneous">5. Miscellaneous</h2>
 <div class="sectionbody">
+<div class="paragraph"><p>&#8230;</p></div>
 <div class="sect2">
 <h3 id="_profiling">5.1. Profiling</h3>
+<div class="paragraph"><p>&#8230;</p></div>
 </div>
 <div class="sect2">
 <h3 id="_unknown_handlers">5.2. Unknown Handlers</h3>
@@ -3864,7 +3905,7 @@
 <div class="sect3">
 <h4 id="_unknown_handlers_for_methods">5.2.1. Unknown Handlers for Methods</h4>
 <div class="paragraph"><p>Object and classes might be equipped
-with a method <tt>unknown</tt> which is called in cases, where an unknown
+with a method <code>unknown</code> which is called in cases, where an unknown
 method is called. The method unknown receives as first argument the
 called method followed by the provided arguments</p></div>
 <div class="paragraph" id="xmp-unknown-method"><div class="title">Listing 48: Unknown Method Handler</div><p></p></div>
@@ -3890,7 +3931,7 @@
   9
  10
 </pre></td><td class='nx-body'><pre class='nx'>::nx::Object <span class='nx-keyword'>create</span> o {
-  <span class='nx-keyword'>:method</span> <span class='nx-keyword'>unknown</span> {called_method args} {
+  <span class='nx-keyword'>:object</span> <span class='nx-keyword'>method</span> <span class='nx-keyword'>unknown</span> {called_method args} {
     <span class='nx-keyword'>puts</span> <span class='nx-string'>"Unknown method '$called_method' called"</span>
   }
 }
@@ -3945,7 +3986,7 @@
  20
  21
  22
-</pre></td><td class='nx-body'><pre class='nx'>::nx::Class <span class='nx-keyword'>public</span> <span class='nx-keyword'>class</span> <span class='nx-keyword'>method</span> __unknown {name} {
+</pre></td><td class='nx-body'><pre class='nx'>::nx::Class <span class='nx-keyword'>public</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>method</span> __unknown {name} {
   <span class='nx-comment'># A very simple unknown handler, showing just how
 </span>  <span class='nx-comment'># the mechanism works.
 </span>  <span class='nx-keyword'>puts</span> <span class='nx-string'>"***** __unknown called with &lt;$name&gt;"</span>
@@ -3958,11 +3999,11 @@
 ::nx::Object <span class='nx-keyword'>create</span> o {
   <span class='nx-comment'># The class M is unknown at this point
 </span>
-  <span class='nx-keyword'>:mixin</span> add M
+  <span class='nx-keyword'>:object</span> <span class='nx-keyword'>mixin</span> add M
   <span class='nx-comment'># The line above has triggered the unknown class handler,
 </span>  <span class='nx-comment'># class M is now defined
 </span>
-  <span class='nx-keyword'>puts</span> [<span class='nx-keyword'>:info</span> <span class='nx-keyword'>mixin</span> classes]
+  <span class='nx-keyword'>puts</span> [<span class='nx-keyword'>:info</span> <span class='nx-keyword'>object</span> <span class='nx-keyword'>mixin</span> classes]
   <span class='nx-comment'># The output will be:
 </span>  <span class='nx-comment'>#     ***** __unknown called with &lt;::M&gt;
 </span>  <span class='nx-comment'>#     ::M
@@ -4072,8 +4113,8 @@
 <div id="footnotes"><hr /></div>
 <div id="footer">
 <div id="footer-text">
-Version 2.1<br />
-Last updated 2012-05-22 10:28:25 CEST
+Version 2.0b5<br />
+Last updated 2013-06-07 10:54:59 CEST
 </div>
 </div>
 </body>
