The fact that your school taught you how to use version control before they taught you to write code is kind of disturbing. I don't know that Ive ever heard of anyone suggesting that version control should be used in the first semester of CS. That seems like a very bad idea.

We didn't lectures on version control before starting or anything like that. The first 'task' was simply to clone a programming exercise from a repository, and later to push the completed exercise back to the repository (the department handles software hand-in by submission of a commit hash). I believe the idea was to get us used to the very basics of version control well before we started needing it for more complex things, so that when we did really need it we could use it easily and concentrate on the actual task at hand.

That still sounds like jumping the gun quite a bit. Most schools just have you write a few simple programs in a text editor for the first few semesters. Normally version control wouldn't be introduced until your sophomore year. I learned about it my freshman year, but only because I was part of a research team that obviously needed it to work together.

It seems that my lecturers would disagree with you; regardless of whether version control is necessary for the simple programs we started with (and here too the course design seems to be different - we wrote an assembler at the end of our third term/second semester(?), for which version control was clearly appropriate) I don't see using it had any negative consequences, nor can I really see any benefits to deferring learning the basics until later in the course.

It is “revision control” not “version control”. Version control is something different.

@QPaysTaxes wikipedia is great, but not always correct. People often mix up revision control / version control / configuration management. Version control is about being able to tell which version of the software you are running, and from that being able to recreate it from source. You could just in-bed a version number in the executable, and the create a shelf full of CD with source and build tools for each version. You could optionally use revision control and store a revision number in the executable (You would also have to put your build tools under configuration management).

Mine did and it was a waste of time because they did it wrong.

As much as I would have appreciated having more practical skills after leaving uni myself, the main purpose of a university education is not to teach you how to use common software development technologies (although you may learn to use them during your courses). Likewise, although the formal constructs VCSs are based on may be interesting from a CS perspective, they likely have a very small audience and aren't hot research topics anyway... so there's little motivation from either side.

Interesting choice of words. You say that you started using git on Day One. But were you really taught how to use it, or were you given "cookbook" knowledge (a "recipe" for you to copy and paste into a terminal window) you were expected to simply parrot to set up your programming environment with a known state, with no real explanation of what the command you were running actually did?

Because most university undergraduate courses, in every discipline, don't teach anything that isn't at least 50 years out of date already. (Look at the stuff posted on by students on SE's like numerical methods, control systems, engineering, etc, etc for evidence.) But whether you call that a "reason" or an "excuse" is a different question!

@errantlinguist "... VCSs ... may be interesting from a CS perspective, they likely have a very small audience ..." What?? Software developers have been using VSC software since before Unix was even invented (and the software like RCS was included in the first versions of Unix for a very good reason!) If you are saying "there are still a few software developers out their who are 40 years behind the curve" then (sadly) I agree with you, but no institution should be training up another generation of them in the 21st century....

... "Not making students aware of VCS systems" is as nonsensical as "never telling them to make backup copies of their computer files" IMO. But since when did academics have their heads anywhere except in a cloud they created from their own hot air emissions?

@alephzero "But since when did academics have their heads anywhere except in a cloud they created from their own hot air emissions?" > if you count things like modelling electromagnetic brain signals or developing quantum computers to be "a cloud they created from their own hot air emissions", then, yes, that's where they are. But I suppose it would make future coder slaves happier to teach them >50-year-old principles of VCSs than quantum computing.

@walrus On closer examination, I think that you may be attending a British 3 year Engineering program, rather than the American 4 year Science program that I was expecting. I think that probably goes a long way to explaining the differences between our experiences.

@MontyHarder yes, we started with the basic 'here's the command to clone a repo' and 'here's how to commit/push to it' at first - just enough to use version control - and then actually learnt how it all worked later.

I question your premise. I've taught version control software as far back as I can remember and would view as deficient any computer science program that did not.

@EllenSpertus whose premise are you questioning?

I question the OP's premise that most universities don't teach Version Control software. Of course, just because something is taught doesn't mean that students learn it.

The question (no longer) claims that most universities don't teach version control, just that many don't.

@kingfrito_5005 Could you elaborate on why it's a "bad idea" to learn revision control before learning to code? In my experience, nearly everyone who isn't at some point forced to use an RCS ends up developing the nasty habit of versioning via folder/file names. I see no reason not to teach the basics of using an RCS prior to learning to code, not least because the use of such systems isn't intrinsically linked to code.

@KyleStrand This isnt the place for a lengthy debate about best teaching practices, but in general I dont think you should teach a person good practices for a skill without teaching them the skill first. Introducing tools before techniques adds unneeded complexity to the learning process. Obviously everyone should learn to use version control, just not before they learn how to write an if statement.

@walrus That makes sense to me. I would expect the pacing and order of classes to be different between those types of degrees, even though they cover essentially the same information.

Just because it is an important skill does not mean it should be the first skill a student should learn. I firmly believe that students should be allowed to concentrate on learning ONE skill at a time. For CS students, version control is useless without code, so it makes sense to teach coding first.