Question

We have many projects that use a common base of shared components (dlls). Currently the development build for each project links against dlls built from the trunk of the components. (ie trunk builds use the dlls from other trunk builds)

When we do a release build, we have a script that goes through the project files and replaces the trunk references to specific numbered versions of the components (that are built from a tagged branch)

I think this weakens the testing that we do during development because the project that I am actually working on is using diferent dlls to what the release build will be using. I would like to always develop against the numbered versions of the components and only ever update them when there is a specific need.

However others in the team argue that unless we develop against trunk (and update to the newer versions of the components with each release) we will have the problem that (a) our products will hardly ever update to the newer version of the components then (b) when we do need to update it will be a huge task because the component source/interfaces will have changed so much.

What practices do you follow, and why?

Edit: Sorry all, I have just realised I have confused things by mentioning that there are several main products sharing components – although they share the components they don’t run on the same PCs. My concern relates to the fact the because the components are likely to change with each release of a product (even though there was no specific requirement to update the component) that testing would miss some subtle change that was done in a component and not related to the specific work being done on the product.

Answer 1

Hmm, I may be in a minority here, but this comes down to release management.

Developing against the trunk of a set of shared components means, by definition, that the components are a ‘moving target’ — a developer using those shared components won’t necessarily know if a newly found defect or failure is due to the project code or the shared components, which leads to a loss of productivity, IMNSHO.

The ‘shared components’ have a release cycle all their own. Give your other developers a break and fix the version of the shared components that the projects are going to use and use tags, labels or branches to identify the shared component release. On the next iteration for the projects, bump up to the latest ‘stable’ or ‘production’ build of the shared components.

There’s another ‘smell’ here, if you’ll pardon the expression. Having ‘shared components’ whose ‘source/interfaces will have changed so much’ between project releases sounds like the components aren’t so solid or shouldn’t necessarily be shared.

See also the answer to this question Shared components throughout all projects, is there a better alternative than svn:externals?