Artifact evolution patterns

The last few posts have concentrated on some of the “micro” aspects of artifact evolution. The most important conclusions include the fact that it’s not good enough simply that the information be structured to support its evolution – it is also important to have:

• a usable and friendly user interface; and
• ready access to process information to support decision making and better understanding of why the changes were made.

I would like to shift gears a bit and talk about the longer-term evolution of artifacts. What does it look like? I think these are best visualized by comparing them to things you find in nature. So this is going to be a gardening lesson, in addition to an examination of evolution patterns for information.

The first pattern is what is called fastigiata, which means there is a central trunk and there are some side shoots, but the side shoots don’t spread out too far. In the SCM world the central trunk is known as the main line. The side shoots are occasional branches that are needed to fix product that has already been released. Often these side shoots are merged back into the main line in a process called propagation. This is the SCM term propagation, not the botanical term, which means something completely different. Sometimes the side shoots are not merged back into the main line because:

• the shoot is a temporary patch that fixes the problem but is not a good long-term solution; or
• the feature it is intended to fix is sufficiently different in the next release that the fix is no longer required.

You see this pattern in high-value source-code artifacts used in the core code-base for products and services. For example, these would be the database access files, or interfaces and abstract base classes in object-oriented languages.

Another pattern is what they call in the orchard business the central leader. There is a main line, but the side shoots go further away from the central leader. The biology analogy does break down a bit because sometimes the side shoots are merged back to the main line. This pattern is found in driver files that are branched each time a variant target is introduced to the product, for example. It is a pattern for files that are used by both head office and application engineers.

One very common pattern is no evolution at all, that is, version 1 or 2, and that’s it. The vast majority of source-code artifacts display this (non) pattern. So if you look at a collection of these artifacts, you might consider them to be grass on a lawn, with the occasional dandelion poking out.

Another pattern is what I call the succulent – okay, this is a particular kind of succulent, but it’s the closest analogous pattern. This pattern is found in ERP systems, in-production websites, or SOA architectures. When an artifact must change, you can’t simply change the one currently in production – that could be disastrous. Downloading it to your workstation doesn’t work because you need to have a full server setup in order to test your changes. Therefore you must follow some or all of these steps:

• Branch the artifact in your repository
• Copy the branched artifact to your development server
• Modify the artifact on the development machine
• Copy the modified artifact to a test machine
• Iterate until all tests succeed
• Merge the artifact back into the main line
• Deploy the new artifact to production

There are variations around this sequence that sometimes cause you to branch numerous times to get around constraints on the test machines, but at the end of the day the main line corresponds to what is in production, and the branches are where you develop and test your changes.

The final pattern is what I call the elm tree because there is no central leader – the artifact branches, and branches, and branches. Problem is, I can’t think of a good example of where such a pattern arises. Perhaps it is found in files that must be modified for each release of a product that has many branches?

Have I missed any patterns? And can you think of an example of an elm tree pattern?