Call it what you want, versioning, revision control, source control, etc., revision control is one of the most important skills a developer should master. It should be as natural as hitting ctrl + S obsessively while writing code. Nowadays, every self-respecting development company uses a revision control system. However, there's a major difference between using one and using one correctly.

If you use it correctly, no one notices it's even there. Everything is natural and when something seems to be complex, it's because the action is complex, not because the tool makes it difficult. The most complex task a revision control system can do is merging, the merge of two branches together. Merging takes time and that's normal. Regular commits and updates are easy and should not be difficult.

If you've had problems with regular commits and updates while working in a development team, you've experienced revision control used the wrong way. Why is it so bad? Because the good practices are not taught in school

The current state of revision control at school

I have yet to meet anyone who has learned to use revision control correctly from their classes in school. Most of the developers I know have used at least one revision control tool at school (usually Subversion), but none of them has ever branched or done merges at school. It always happened during an internship or after graduating.

In my experience, this has always been part of a small project where the teacher would give a project that had to be done in a team and he would provide the repository. However, the teacher would talk about the different concepts of revision control, but would not enforce the students to fully use the revision control tool. All the students every did was checkout once and then commit and update all on the same branch (usually called the trunk).

Everyone I know learned by experience in their first few jobs (if they were lucky enough to get a job where they used revision control, though that's less of a problem now).

I think a few projects focusing on the revision control part of development should be mandatory. It would only take a month or two, but the students would be much more prepared when hitting their first job.

Where can I learn more about revision control?

I'll be posting more about revision control in the future, however here are a few very good resources to get started.

First of all, everyone should read this Source Control HOWTO by Eric Sink from start to finish. If you're already an experienced revision control user, you'll be able to skip some parts, but you should at least take a look at everything.

This article about software branching by Jeff Atwood covers many branching strategies and it's a must-read. It's not very long, but will help you a lot. It's pretty much a rewrite of this Branching and Merging Primer MSDN article, but offers another developer's perspective on the topic. Both articles are worth the time you'll spend reading them.

Final note

If revision control is not natural to you or your team, take action to improve this skill, it's one of the most important skills of a developer (after actually being a competent developer).