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.
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.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.
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.
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.
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.