Using SVN with multi-user development

Question

My team uses SVN to manage their source. I was tasked with figuring out if there is a way to improve the way I use SVN.

I read most of the SVN book and did a lot of research on how others use SVN.

I will talk about how we use svn, and hopefully someone has suggestions for me.

First of all, we have a release every month or two. Therefore, we are currently using the trunk as our production copy of the code, and we are creating a release branch for each planned delivery and for each production patch.

Usually we have two, sometimes three, planned deliveries going at the same time. For example, I could code release 3, but I or others are testing release 2 and make final bug fixes for release 1. A production fix could happen at the same time.

Now we are doing a lot of merges to synchronize branches (each version). Version 3 needs a code from 2 and 1, but we obviously do not want the new code from release 3 to hit release 1. Thus, we would make a series of mergers from release 1 to release 2 and from release 2 to release 3 This must be repeated on a regular basis so that the third release encoders have and correct errors from 2 or 1.

Whenever a release or production fix goes into production, we merge the code back into the trunk. Then we will combine it with the trunk (or the liberation branch that just went into production) into all active branches.

As you may have noticed, we spend a lot of time merging.

This is a big job for the person who controls the initial control. They constantly merge and make sure to keep track of which branches are merging there.

It seems that SVN is our source code management system (I know that this is only version control, but we use it to manage our source code) should be able to help us with this.

For example, it would be great if the developer working on release 3 knew that something had changed in version 2, release 1, or the body, and that developer could be automatically notified, and he could merge to make changes to his branch. But instead, someone should know to do all the merges manually ... It seems like a person is doing too much work and the machine is not doing enough.

Does anyone have any ideas on how we could make better use of the SVN features so that we can save ourselves from this headache and make sure everyone always works with the code versions that they should be!

Thanks!

Answer 1

I do not know that you can really solve this situation by asking questions and answers on the forum. The best option would be to view Professional Services from a company such as my employer, CollabNet. Subversion Learning Features

Let them put names like “chest” for a moment, because these things mean what you want them to mean. I am one of the committers for Subversion Apache, and I would recommend making the development somewhat the same as for Subversion.

• Almost all development work is carried out in one place, which we call trunk, but can be called "development" or "unstable" or any other name that you want.
• Some work on new features will be performed in feature branches created from the trunk. Usually they are short-lived and at the discretion of the developer. We try to constantly maintain a stable baggage (all tests pass), so sometimes people want to first try the devastating changes on the branch.
• At some point, we think that the trunk received the functions that we want to start the release, so the release branch is created by copying the trunk.
• We do not allow any development in the release branch. Errors are recorded in the trunk, and the audit (s) that contain the fix are assigned for backup to one or more issues. If they are approved, then the audit will be merged with the branch (s) of the issue for which they were approved.
• Sometimes the trunk is quite at odds with the release that the fix will not merge cleanly. When this happens, we create the backport branch by copying the release branch, and then merge the patch from the connector into the backport branch. This allows the developer to properly resolve merge conflicts at the branch and other developers to properly analyze and vote on whether to indicate an error.

This model works well, because changes always merge in only one direction, and you don’t have to worry about someone quickly fixing some issues and then forgetting to make the same correction in the trunk. Therefore, the error does not appear in the next version.

I will point out that Subversion development is pretty linear. You do not have 3 releases in flight, as you indicated above. We still support 3 releases at a time, but the number of fixes in the reverse order is small. I think this process could work for a more flexible environment, as you describe, but I think it would be better for you if the service specialist worked more carefully, trying to smooth it out.