> urticator.net

  About This Site
> Domains

> Computers

> Concepts for Persistent Objects
  Language Design Principles

  Instances and Copies
> Branches and Growth Points
  Synchronization and Merging
  An Example

Branches and Growth Points


Now let's return to the insurance contract example. We had three versions, remember, an original, a revised version, and a version we'd just made.

Next, let's suppose the company web site is still showing the intermediate version, and someone finds a spelling error in it. We can't replace it with the version we just made, that has to go through legal review first, so instead we have to go back to the intermediate version and correct the spelling error.

Even now, we still think of the contract as a single object; the object isn't just a series of versions, it's a whole tree, and the new version starts a new branch.

I claim there's more to it than that, however. To see why, let's go back and imagine a slightly different scenario. Instead of a spelling error being found, suppose a branch office requests that the intermediate version of the contract be translated into Spanish. The main office agrees, the contract is sent out to a translator, and eventually a translated version returns. The point I wish to make is that our concept of the insurance contract already includes the beginning of a new branch even before the translated version returns—in fact, even before the translator starts work, and possibly even before the contract is sent out. Thus, there are two independent events that take place: the creation of a new point where tree growth can occur, and then the actual appearance of a new version at that point.

These points where tree growth can occur I will unimaginatively call growth points. It would be possible to continue the tree analogy and call them buds, but for some reason that just doesn't grab me. (It's probably because growth points can go away, and I don't think of buds as doing that.)

Here are some assorted thoughts about growth points and branches.

First of all, although growth points are not always tangible entities, once you get used to them, they're about as real as versions and objects. Growth points can be created and destroyed, and more than one growth point can exist on the same version.

Although it's not quite correct, I find it helpful to think of growth points as allocations of processing power. “Processing power” isn't the right phrase, because I'm talking about people, not computers, but it gives the right idea. In the example above, the created growth point represents the fact that the translator would be working on the intermediate version and producing a new, translated version, while the existing growth point represents the fact that we were still working on the main branch. In other words, a growth point represents a person—or agent, or subject—that is responsible for working on the object in a particular way, starting from a particular version. That's still not quite right, though. As in the example of the spelling error, it's possible for a single person to be in charge of multiple growth points; it's also possible for a group of people to have joint responsibility for a single growth point. So, a growth point doesn't represent a person, but rather a role or capacity.

It's also instructive to think about processes, particularly in Unix. On the one hand, a process can act as an agent to modify some external object at a growth point, just as a person can. On the other hand, if we think of the internal state of the process as the object, then the process literally is a growth point, an allocation of processing power. Such growth points are entirely tangible, they are created when fork is called and destroyed when exit is called.

I'm sure there is some general lesson about roles and processes to be extracted from the above, but I can't figure out what it is. Let me know if you see it.

As long as I'm throwing out things I don't fully understand, here's another suggestive tidbit. What happens when a management consultant designs a business process for employees to follow? The employees act on the process state, of course, but in doing so also cause external objects to be modified. Thus, the process acts both as object and as agent.

Finally, it's worth noting that I intend the word “branch” to refer specifically to an actual set of branched versions, and not to any kind of associated growth point. There can be growth points without branches, as when the translator is just beginning to work, and also branches without growth points, as when the translator's work is completely done. Well, actually I might correct that a little. When the translator is just beginning to work, I'd most likely say there is a branch, a set of versions, it just happens to be an empty set at the moment.



  See Also

  Another View (Free Time)
  Attention in Myth
  Synchronization and Merging

@ September (2000)