I disagree, except maybe in a class specifically focused on real-world software engineering. Teaching somebody to use git takes an afternoon, teaching somebody to understand programming and computation takes years.
Git is not a skill, it is a habit. Anyone in computer science should have developed this habit.
This is for many reasons. Version control is not only about controlling versions.
- It's not about saving files, it's about understanding group work flows. Every text project should be in a git repo. If it's code or not it doesn't matter. You can see what things were written for, who wrote them, and even more.
- It's a method to catch cheating. If someone submits one commit called "Working" or something and has no history of the code/project it's likely they are cheating.
- It's decentralized backups and and offline workflow (for git)
- It's a method to collect and aggregate work. Setup a gitlabs/gitbucket for the class and make every student keep their projects up there. The teacher has a centralized and nice looking place to find the code and it doesn't make the students zip up or require them to do anything. Their work is shared by nature.
- It exposes you to what you are going to be using every day for the rest of your life as a CS major.
It's not a question of how useful VCS is. It's a question about what the role of universities is.
In the US/Canada college degrees are generally not directly training you for a career -- that's what internships are for. My position is that this is the right approach. I will have a lifetime to perfect my git skills, but I only had four years to learn about programming language semantics from a recognized expert in the field.
Hopefully your CS degree made you write code and submit code for evaluation. Asking you to write code and not teaching you how to use version control is wasting your time fixing problems with your code that are easily solved when you have version control. Being taught how to use version control leaves you more time to learn about programming language semantics.
Also, a university that gives CS degrees to people who cannot actually work as programmers is doing a disservice to their graduates, even if the university intends for everyone to continue with post graduate studies and go into academia. At the very least, your doctoral advisor will need you to write some code for them, and you better be able to do it.
You can give few neat basic commands of basic git usage but many people just nope out after git add -A . and never learn how to actually use it. It's god awful to actually realize that your peers are not capable or willing to do more.
This is exactly the kind of class I believe should be available to everyone studying software engineering (or similar). Version control is just one of many technologies and skills that most people I know didn't see until after University.
Development process and software engineering should be part of any good course. At my university we had basic, ffirst year courses covering some practical coding, shell programming and various other sorts of usefuk stuff.
I didn't appreciate why version control was so important until later, but at least I knew what it was. Now I consider a department with either no real vcs strategy, or an outdated, cumbersome one to be a huge red flag.
One place I worked used source control, kinda. They had an old system, sccs, and they used to pull together patchsets into zip files, name the zip after the (unique) bug number it addressed and put the zip into the vcs. Here was then a lotus notes database that recorded what the fix was for, what version it applied to, other pre-requisite fixes before this patch... So painful. The graduate software engineers they took on actually developed fear and nervousness of vcs and tried to avoid it as much as possible. That was back in about 2002...
Just stick it into CS 101 (give it an afternoon), and then treat it like a prerequisite. Require that all students use VCS for projects in all other courses.
It's really not hard. Even for most of my non-CS classes I maintained a git repo just for notes.
Even if you set aside the benefit of learning and building a useful real-world skill, mandating git usage will likely save almost every student from a disaster at some point during their studies.
Some of those years of teaching might be less stressful and more productive if the student had appropriate tools and skills.
Version control can act like a safety net that lets you try things and explore with more reassurance that you won't utterly trash your progress so far.
