<p>I agree with the CSTA Standards that revision control is an important skill by upper high school.  My school has a GitHub account and it is good for both revision practice and for using Agile boards for task management, which is an important methodology for students to know as they move to college.  I think there is value in either GUI or Command Line knowledge.  </p>

<p>Here are some resources about Agile in Education:
<a href="https://www.agileineducation.org/examples.html" rel="nofollow noreferrer">https://www.agileineducation.org/examples.html</a></p>

<p>I like this resource for revision control:
<a href="https://betterexplained.com/articles/a-visual-guide-to-version-control/" rel="nofollow noreferrer">https://betterexplained.com/articles/a-visual-guide-to-version-control/</a></p>

<p>The main ideas are backup/restore, synchronize (sharing resources with multiple people), tracking changes, sandboxes, branching, and merging.</p>

CC BY-SA 4.0
2019-03-20T13:53:32.697Z
This answer is a bit of a stub.  Would you mind expanding on what you've said here?  If it is helpful, it seems like these two parts were unaddressed in your answer: *What are essential skills with revision control tools? What are best practices (or good sources for learning about them)?*
Ben I.
CC BY-SA 4.0
2019-03-20T21:35:42.753Z
Would love to hear about how you’re incorporating Agile boards into your classes.
dlu
CC BY-SA 4.0
2019-03-20T13:36:49.430Z
2019-03-21T14:26:49.533Z
2019-03-21T14:26:49.533Z
Charlotte Dungan
<p>It's encouraging to see these skills start to make their way in earlier in computing education. I'm a college professor and teach (among other things) our Software Engineering class so this subject is near and dear to my heart. To answer your questions one by one:</p>

<blockquote>
  <p>When does revision control rise to the level of a "needed understanding" for students?</p>
</blockquote>

<p>From what I observe, it becomes most essential once students are working on non-trivial projects. That is, once projects are collaborative OR last for more than a couple weeks OR intend to be actual software with real users, then maintaining versions of the source code becomes more and more valuable. With the combination of more than one of those factors, it becomes more essential.</p>

<blockquote>
  <p>What are essential skills with revision control tools?</p>
</blockquote>

<p>Essential to a professional or to a beginning programmer? To put it broadly, college students should learn to be able to efficiently share code across a team and maintain its versions over time. That means being comfortable working with remote repositories and resolving merge conflicts as well.</p>

<blockquote>
  <p>What are best practices (or good sources for learning about them)?</p>
</blockquote>

<p>That is a big question that could have its own long answer. However, since your students will be working in teams, one of the worst habits I see in students is when they want their code to be perfect and "done" before sharing it with anyone else. This often comes from a place of either perfectionism or a lack of confidence. When students wait too long to try to merge their work with others', the differences are often very difficult to resolve. Get students to practice making targeted, small changes and sharing those revisions early and often.</p>

<blockquote>
  <p>What tools to teach? I'm comfortable with Git and GitHub, and they are widely used, but are they good teaching tools?</p>
</blockquote>

<p>Yes, they work well and students tend to appreciate gaining exposure to them because they are so common in industry. GitHub is steadily improving in how they support educational use. Students can get free accounts and <a href="https://classroom.github.com/" rel="nofollow noreferrer">GitHub Classroom</a> is helpful at some unique classroom needs (such as batch downloading all project submissions, or giving students "skeleton" code but keeping each student's fork private to just the individual student and the instructor).</p>

<blockquote>
  <p>Command line vs. GUI vs. IDE integrated interface?</p>
</blockquote>

<p>Use what works with the rest of your class. I wouldn't change your environment just for the sake of Git. Several popular IDEs now integrate Git (and remote hosts like GitHub), but if you're not already using one that supports it, I recommend <a href="https://gitkraken.com" rel="nofollow noreferrer">GitKraken</a> -- a free, cross-platform GUI application -- if you want a consistent, easy interface for students.</p>

<p>Personally, I just use command line (and my students do too, but that doesn't necessarily mean it is appropriate for all classes/students).</p>

<blockquote>
  <p>If you're a college CS teacher, what do you want your incoming students to know?</p>
</blockquote>

<p>Honestly, most students don't come in with any previous experience. Even in my (upper-level) Software Engineering class, I have to work with the assumption that <em>some</em> students will have never seen git before my class. In that respect, anything will be an improvement.</p>

<p>However, one request I make is try to avoid students getting in the habit of automatically staging <em>all changed files</em> (using <code>git commit -a</code> or <code>git add .</code>) <em>all the time</em>. It is a habit that is hard to break and makes for poor version documentation and ugly messes of unrelated changes being lumped together.</p>

<p>I also highly recommend using <a href="https://learngitbranching.js.org/" rel="nofollow noreferrer">js.org's Learn Git Branching</a> interactive tutorial, which is conveniently broken into small modules so you can assign the ones you think are most appropriate for your students. In Software Engineering, I require students to complete all the modules, but in introductory programming classes, they usually just learn some very basics (init, clone, pull, push, status, add, commit).</p>

CC BY-SA 4.0
2019-03-23T12:47:45.283Z
What a detailed and helpful reply! I will be making good use of this post over the next few weeks.
Ben I.
CC BY-SA 4.0
2019-03-23T00:58:06.670Z
2019-03-23T00:58:06.670Z
Kevin Buffardi
<p>I teach AP Computer Science A and game design classes at the high school level in Washington state (where "revision control systems" are a grade level expectation (GLE) for 11th and 12th grade - all of the classes are mixed grade level, but that is probably a discussion for another day). We use the game design classes as our "bait" to get kids interested in CS, but there are usually some pretty sharp and motivated kids in those classes.</p>

<p>I want the students to work on collaborative projects and many of them want an easy way to move their work back and forth between home and our lab. This, and having a way to make mistakes and then back out of them (and the state GLEs) are motivating me to teach them how to use a revision control system. I'm inclined towards Git and GitHub both because I have experience with them and because GitHub offers private repositories to schools.</p>

<p>Our intro level game design class uses Code.orgs Game Lab which has a minimal, but useful revision control system. In AP CS and the upper level game design class we use a JetBrains IDEA (IDEA and Rider respectively) which have support for a variety of revision control systems built in.</p>

<p>So the questions:</p>

<ul>
<li>When does revision control rise to the level of a "needed understanding" for students?</li>
<li>What are essential skills with revision control tools?</li>
<li>What are best practices (or good sources for learning about them)?</li>
<li>What tools to teach? I'm comfortable with Git and GitHub, and they are widely used, but are they good teaching tools?</li>
<li>Command line vs. GUI vs. IDE integrated interface?</li>
<li>If you're a college CS teacher, what do you want your incoming students to know?</li>
</ul>

CC BY-SA 4.0
2019-03-19T00:13:34.420Z
You may be interested in https://cseducators.stackexchange.com/q/2897/204 Maybe you can help by giving an answer. Consider also mercurial (in my opinion easier to use), and bitbucket: ≤5 users private repositories are free, public repositories are free, teacher accounts are free, and less/un redistricted.
ctrl-alt-delor
CC BY-SA 4.0
2019-03-19T00:15:06.973Z
Note: revision-control ≠ change-control ≠ source-control ≠ version-control.
ctrl-alt-delor
CC BY-SA 4.0
2019-04-22T19:26:32.170Z
No matter what you do NOT start with Git! It's worst kind of revision control for a beginner. It actually doesn't make any sense in the classroom setup. Start with something basic, maybe even rsync to get an idea of what this is and why one needs it
Aksakal almost surely binary
CC BY-SA 4.0
2019-04-22T22:49:55.917Z
@Aksakal - Does rsync run on Windows? Students want access to their work from home and the ability to collaborate in class. Could you expand on what you see as the problems are with Git and GitHub?
dlu
<curriculum-design><revision-control><github><git>
Teaching Revision (Change) Control Systems In High School CS Classes
# Teaching Revision (Change) Control Systems In High School CS Classes

(Asked by: username_0 on 2019-03-17)

I teach AP Computer Science A and game design classes at the high school level in Washington state (where "revision control systems" are a grade level expectation (GLE) for 11th and 12th grade - all of the classes are mixed grade level, but that is probably a discussion for another day). We use the game design classes as our "bait" to get kids interested in CS, but there are usually some pretty sharp and motivated kids in those classes.

I want the students to work on collaborative projects and many of them want an easy way to move their work back and forth between home and our lab. This, and having a way to make mistakes and then back out of them (and the state GLEs) are motivating me to teach them how to use a revision control system. I'm inclined towards Git and GitHub both because I have experience with them and because GitHub offers private repositories to schools.

Our intro level game design class uses Code.orgs Game Lab which has a minimal, but useful revision control system. In AP CS and the upper level game design class we use a JetBrains IDEA (IDEA and Rider respectively) which have support for a variety of revision control systems built in.

So the questions:

* When does revision control rise to the level of a "needed understanding" for students?
* What are essential skills with revision control tools?
* What are best practices (or good sources for learning about them)?
* What tools to teach? I'm comfortable with Git and GitHub, and they are widely used, but are they good teaching tools?
* Command line vs. GUI vs. IDE integrated interface?
* If you're a college CS teacher, what do you want your incoming students to know?

**Tags:** curriculum-design, revision-control, github, git

> **Comments:**
> **username_1**: You may be interested in https://cseducators.stackexchange.com/q/2897/204 Maybe you can help by giving an answer. Consider also mercurial (in my opinion easier to use), and bitbucket: ≤5 users private repositories are free, public repositories are free, teacher accounts are free, and less/un redistricted.  
> **username_1**: Note: revision-control ≠ change-control ≠ source-control ≠ version-control.  
> **username_2**: No matter what you do NOT start with Git! It's worst kind of revision control for a beginner. It actually doesn't make any sense in the classroom setup. Start with something basic, maybe even rsync to get an idea of what this is and why one needs it  
> **username_0**: @Aksakal - Does rsync run on Windows? Students want access to their work from home and the ability to collaborate in class. Could you expand on what you see as the problems are with Git and GitHub?  

---

## 2 answers

### Answer by username_3 on 2019-03-20. Score: 2

I agree with the CSTA Standards that revision control is an important skill by upper high school. My school has a GitHub account and it is good for both revision practice and for using Agile boards for task management, which is an important methodology for students to know as they move to college. I think there is value in either GUI or Command Line knowledge.

Here are some resources about Agile in Education:
<https://www.agileineducation.org/examples.html>

I like this resource for revision control:
<https://betterexplained.com/articles/a-visual-guide-to-version-control/>

The main ideas are backup/restore, synchronize (sharing resources with multiple people), tracking changes, sandboxes, branching, and merging.

> **Comments:**
> **username_4**: This answer is a bit of a stub.  Would you mind expanding on what you've said here?  If it is helpful, it seems like these two parts were unaddressed in your answer: *What are essential skills with revision control tools? What are best practices (or good sources for learning about them)?*  
> **username_0**: Would love to hear about how you’re incorporating Agile boards into your classes.  

---

### Answer by username_5 on 2019-03-23. Score: 2

It's encouraging to see these skills start to make their way in earlier in computing education. I'm a college professor and teach (among other things) our Software Engineering class so this subject is near and dear to my heart. To answer your questions one by one:

> When does revision control rise to the level of a "needed understanding" for students?

From what I observe, it becomes most essential once students are working on non-trivial projects. That is, once projects are collaborative OR last for more than a couple weeks OR intend to be actual software with real users, then maintaining versions of the source code becomes more and more valuable. With the combination of more than one of those factors, it becomes more essential.

> What are essential skills with revision control tools?

Essential to a professional or to a beginning programmer? To put it broadly, college students should learn to be able to efficiently share code across a team and maintain its versions over time. That means being comfortable working with remote repositories and resolving merge conflicts as well.

> What are best practices (or good sources for learning about them)?

That is a big question that could have its own long answer. However, since your students will be working in teams, one of the worst habits I see in students is when they want their code to be perfect and "done" before sharing it with anyone else. This often comes from a place of either perfectionism or a lack of confidence. When students wait too long to try to merge their work with others', the differences are often very difficult to resolve. Get students to practice making targeted, small changes and sharing those revisions early and often.

> What tools to teach? I'm comfortable with Git and GitHub, and they are widely used, but are they good teaching tools?

Yes, they work well and students tend to appreciate gaining exposure to them because they are so common in industry. GitHub is steadily improving in how they support educational use. Students can get free accounts and [GitHub Classroom](https://classroom.github.com/) is helpful at some unique classroom needs (such as batch downloading all project submissions, or giving students "skeleton" code but keeping each student's fork private to just the individual student and the instructor).

> Command line vs. GUI vs. IDE integrated interface?

Use what works with the rest of your class. I wouldn't change your environment just for the sake of Git. Several popular IDEs now integrate Git (and remote hosts like GitHub), but if you're not already using one that supports it, I recommend [GitKraken](https://gitkraken.com) -- a free, cross-platform GUI application -- if you want a consistent, easy interface for students.

Personally, I just use command line (and my students do too, but that doesn't necessarily mean it is appropriate for all classes/students).

> If you're a college CS teacher, what do you want your incoming students to know?

Honestly, most students don't come in with any previous experience. Even in my (upper-level) Software Engineering class, I have to work with the assumption that *some* students will have never seen git before my class. In that respect, anything will be an improvement.

However, one request I make is try to avoid students getting in the habit of automatically staging *all changed files* (using `git commit -a` or `git add .`) *all the time*. It is a habit that is hard to break and makes for poor version documentation and ugly messes of unrelated changes being lumped together.

I also highly recommend using [js.org's Learn Git Branching](https://learngitbranching.js.org/) interactive tutorial, which is conveniently broken into small modules so you can assign the ones you think are most appropriate for your students. In Software Engineering, I require students to complete all the modules, but in introductory programming classes, they usually just learn some very basics (init, clone, pull, push, status, add, commit).

> **Comments:**
> **username_4**: What a detailed and helpful reply! I will be making good use of this post over the next few weeks.  

---

