Subversion, best practice for a small team of 5 developers?
We have svn setup via Assembla with CI Team City. I understand the source of control, is my team new to this? How should we proceed with our work? Now our environment is not organized the way it should be. I am also trying to get Trac to work in our group. What should we do every person working where there is a branch? Merge the changes back into the trunk when they are done? Or letting them work the barrel and hopefully Teamcity will catch the bad stuff?
source to share
1. How should we continue to work? If the team is new to configuration management, your short term goal should be to allow them to operate in a controlled manner with MINIMUM disruption to their operation. This means that you need to separate your personal configuration goals into short and long term goals. Be prepared to redefine your long term goals as the team learns!
2. Now our environment is not organized the way it should be. A good configuration manager will always think about this. The last thing you want to do is make it feel like you prefer process over "real work," so keep moving and think of evolution here, not revolution. Like software, defining a team process requires a "plan" and good communication.
3. I am also trying to get Trac to work in our group. Nice move. Initially, TRAC will let your developers see what's going on. But it also has tickets, milestones, revisions, priorities, and a bunch of other convoluted tools that can get in the way of your developers. So, first use trac as a svn timeline view and handy tool. Submit tickets / stages, etc., when they are comfortable with the toolbox itself, and be prepared to never use them if they don't need / need them.
4. What should we do each person who works where there is a branch? Merge the torso changes again when done? In the end, maybe. But have you identified a problem that will help you solve the merge / merge problem? Remember, your team may never have encountered such problems. My recommendation here is to wait until you run into a problem and then solve it as a team under your leadership.
5. Or letting them work with the trunk and hopefully Teamcity will catch the bad stuff? First, yes. Then, imagine all the good things you know about CM when you have problems, not before.
Remember, you are building a software product, not a great configuration management system. Thus, keep it simple and only use the tools / processes that will enable you to create a better product as a team. Obviously, you've figured out the importance of configuration management along the way, so let your developers know too. Guide them, don't force the process on them. Start with the obvious stuff ("SVN allows us to share code in a controlled way") and work your way up from there. Good luck!
source to share
What should we do for each person to work on their branch? Merge the changes back into the torso when done?
I'm usually not a proponent of this as the developer fork is clumsy and it's hard for a specific developer to figure out that everyone else is working along the way looking at the same branch. You could mitigate this a bit by asking everyone to merge into the chest with every commit, but then why do you have a branch at all?
Or letting them work with the trunk and hopefully Teamcity will catch the bad stuff?
My recommendation here was to get a developer buy-in to make a command rule: everyone gets updated and goes to the mainline, and they run (all) tests locally before committing them. Branches in Subversion are more efficiently used for feature sets like the one for an upcoming release, rather than separate testing conditions for features.
I think your CI should be a safety net to alert you that things are not in the state you expect them to be. But it helps if your developers understand that they shouldn't be reviewing code that doesn't pass in the first place.
source to share
I found myself in a similar situation, we are a team of three, and I was the one who insisted on version control even though my experience with it is limited and I learn when I leave. I found this article extremely helpful: http://www.ericsink.com/scm/source_control.html
If your team hasn't read it yet, they definitely should - it's a great starting point.
After trying everyone on my own branch and then merging with the backbone method, I can tell you from our mistakes that it was painful and confusing to say the least. If you are the most seasoned and they are new to this, then chances are you are the one to take responsibility for merging all these branches together ... not fun.
Everyone who ran away from the chest was the least painful, I would say it is almost a joy compared to how we worked before. You can all benefit from improvements made to each other in separate files, differences will automatically update and merge (if no conflict exists). It will also allow your team to get used to how version control works, and you gradually become more comfortable with its mechanics, and then you should learn about branching and merging.
In short: Baby steps :-)
It will pay off in the long run.
source to share
I have used svn this way and have never complained about it. I think your strategy depends on what kind of software you are developing. In my case, it was a product used by many different clients and available for several different versions in a critical environment (factory automation).
- The string must always compile.
- Tag for each version
- All fixes and minor changes should be done on the trunk.
- A branch for each version of the major version.
- All major developments are carried out in a specialized industry. They merge after QA.
- All fixes are also made in each branch of the supported versions.
It may look heavy, but it works fine and could serve many users. For such critical software, everyone wants to be sure what is inside the new version.
If you don't have such a limit, 1 to 3 may be sufficient. Branching is sometimes painful.
If you need to run multiple large projects in parallel, you may need to treat DVCS as mercury or git.
source to share