+ value = a.name # Get the name of 'a'.
+ a.name = value # Set the name of 'a'.
+respectively **set** and **get** the *name* attribute of the object
+*a*. Inheritance is where an object gets some its attributes from one
+object in the tree has a parent object, which is also called the
+prototype object (of the child). There is a single exception to this
+rule, which is the **root** of the tree. The root of the tree does
+not have a parent object.
+looks up the name of the attribute in the object's dictionary. If the
+name is a key in the dictionary, the associated value is returned.
+If the name is not a key, then the process is repeated using the
+object's parent, grandparent, and so on until the key is found. If
+the key is not found in this way then (see :ref:`object-missing-keys`)
+*undefined* is returned.
+ignores the inheritance tree. It simply sets that value in the
+object's dictionary. With Python its just the same. (However,
+When the interpreter starts up, the **root** of the tree is placed at
+Every object inherits from the **root**, although perhaps not
+directly. Here's an example:
+ js> root = Object.prototype
+ js> a.name === undefined
+ js> root.name = 'gotcha'
+Once we give *root* a *name* attribute every other object, including
+those already created and those not yet created, also has a *name*
+attribute with the same value.
+However, this does not apply if *name* is found earlier in the tree.
+We continue the previous example to show this, and the behaviour of
+Any tree can be constructed from its root, together with a command
+**create(parent)** that returns a new **child** of the given parent
+it should be). However, it's easy to write one [link], once you know
+Here's an example of its use:
+And a continuation of the example: