Over time, I have discovered just how varied the approaches are to development integration efforts. At the risk of abusing some terms, I'm going to generalize them into two separate camps. The optimistic crowd, and the pessimistic crowd.

The pessimistic approach is something I used to do once upon a time a long time ago. Generally, it goes something like: get a current copy of the thing you want to work on, do your work, then publish it as a branch. Now do another pass, where you integrate your branch, and the branches that any others may have produced, and weld the composite back into the main stream. Rinse, repeat. I think this approach is particular appealing if you like to do big batches of work. Or if your faith in the tools is not that high. Or if you want an additional check and balance. We use this approach here at Cincom. It's not necessarily bad. It's what it is, and it's a process many are comfortable with.

The optimistic approach is a bit different. It tends to favor constant and frequent integration over branching. Over the years, adherents in this community have often come to the conclusion that working with branches is just always going to be extra work. So the model here goes something like: Get a current copy of the version you want to work on, and begin doing your work. As work progresses, you periodically check to see if the work of others to the same thing has been published yet (either through manual checking, or automated tools that inform you). When you see that happen, at some point, you take the new code, and merge it and your changes and keep going. When you're done, you check one more time, and then publish. Those who use cvs or svn will recognize this as "svn/cvs update". It does basically that. This model tends to work well when people keep their changes small and incremental and are constantly integrating stuff. It amortizes the integration process in with development, so there is not a second pass when you go to fold your changes in.

The StORE tools have tended to favor/encourage the pessimistic model. A long time ago, I posted a recipe on how to do something more like the optimistic model with StORE. After doing some recent Store/Merge work with the new merge tool, I figured I now knew enough to try and automate this very process. If you load the latest version of StoreExtensions from the OpenRepository, you'll find that there's an option added to the Store "Versions Browser" which can "Upsync Image." It will basically, run the merge tool without opening it. If it can detect that there are no conflicts, it will apply them, and then reconcile to the selected version so that that is now the point you are developing from. If there is a conflict, it'll open the merge tool.

It's kind of hackish, and I make no claims as to whether I dealt correctly with the edge cases. But it seemed to work fine on some simplistic cases I ran. Enjoy.