Every object has its own set of variables, called its object variable pool. These are variables associated solely with the object--rather than with any one method belonging to the object. When an object's method runs, the first thing it does is identify the object variables it intends to work with. Technically, it "exposes" these variables, using the REXX instruction EXPOSE. Exposing the object's variables distinguishes them from variables used by the method itself, which are not exposed. Every method an object owns--that is, all the instance methodsin the object's class--can expose variables from the object's variable pool.
Therefore, an object variable pool includes:
Recall that all of a class's variables, together with the methods that expose them, are called a class scope. REXX exploits this idea of class scope to achieve concurrency. To explain, the object variable pool is really a collection of variable subpools. Each subpool is at a different scope in the object's inheritance chain. As long as the methods running on the object are at different scopes, they can run simultaneously.
Let's amplify this point further. Scopes, like objects, hide and protect data from outside manipulation. Methods at the same scope share the variable subpools at that scope. The scope shields the variable subpools from methods operating at other scopes. This lets you reuse variable names from class to class, without fear the variables could be accessed and possibly corrupted by a method outside their own class. So class scopes effectively partition an object's variable pool into subpools that can operate independently of one another. Multiple methods can use the same variable pool concurrently, as long as they confine themselves to variables in their own subpools.