Nearly every conversation the GitHub Education team had with teachers at SIGCSE 2018 (Special Interest Group on Computer Science Education) touched on the themes of communication, iteration, and real-world tools. This year at SIGCSE we had two special sessions on those themes: three teachers walked through their GitHub workflows, and four students shared their experiences outside the classroom.

Teacher panel: Real-world tools, engaged students

Git has a learning curve for students (and teachers)! In this series of talks, teachers shared why they choose to use Git and GitHub and how it benefits their classroom.

Or skip to a specific section:

• 2m50s: Ming Chow, Tufts University
• 18m30s: Dr. Mine Çetinkaya-Rundel, Duke University
• 36m00s: Dr. John David Dionisio, Loyola Marymount University

Check out teacher slides

Student panel: Outside the classroom

Hear students speak about using GitHub and the benefits of GitHub Education on their campuses.

Or skip to a specific section:

• 2m15s: Amy Dickens, University of Nottingham
• 18m20s: John Pham, University of California, Riverside
• 27m45s: Chris Cannon, North Carolina Agricultural and Technical
• 42m00s: Elliot Whitehead, University of Colorado, Boulder

Check out student slides

Sign up for lesson plans, tutorials, and best practices from GitHub Education

Once a month we’ll pass along tips and tricks for implementing Git and GitHub in your classroom.

Subscribe for updates

Like professional developers working together on code, students can use GitHub Classroom to collaborate on group projects in a shared repository. In this post, we’ll walk you through how teachers can work with GitHub teams and use GitHub Classroom to create group exercises, assign teams, and reuse existing student teams.

Before you begin

Before you create a group exercise, you’ll need the following:

• A GitHub organization with a discount for private repositories and access to GitHub Classroom

• An exercise (a repository that you have access to, which contains documentation, starter code, tests, or anything else your students need to begin work on an assignment)

• A list of students, or unique identifiers like their email addresses

Get started

To get started, log in to GitHub Classroom, choose one of your classrooms, then click the New assignment button followed by Create group assignment. This brings you to the “New group assignment” page where you can provide the details of an assignment. If you don’t see your classroom listed, double check that you’ve granted that organization access to GitHub Classroom.

Then set up your group assignment just like you’d setup an individual assignment. Pick a name for your exercise, a starter repository to share, and a deadline.

Create and use groups

When creating a new exercise, you can choose whether to reuse a set of groups from a previous assignment or name a set of new groups. If you’re reusing existing groups, then select a set of teams from the “Choose an existing set of groups” drop-down list.

If your students are going to form a new set of teams, enter a name for the set of teams in the “Create a new set of teams” field. It’s helpful to name your set of teams after their intended duration. For example, if you want to use a set of teams for one assignment, name it after that assignment. If you’d like to reuse a set of teams for a whole semester, name it after the semester or course.

When you’ve completed the form, click the “Create Assignment” button. Now it’s time to invite your students to the assignment.

Form student groups

On the assignment page, you’ll find a unique invitation link. Share this link with your students through your learning management system, course homepage, or however you distribute assignments. Keep in mind that anyone with the link can use it, so be careful where you share it.

If you’re using a new set of groups for this exercise, and you’d like to assign students to specific group, give your students a list of people who should join each group, along with the group’s name.

Once your students have clicked the link, they may be asked to join a group (if you’re not reusing an existing set of groups). It looks like this:

There are three common cases when organizing students into teams:

• There are no groups yet. The student will have to enter the name of a new group to create it
• There are one or more groups already formed. The student clicks on the existing group they want to join
• A student needs to create a new group. The student enters the name of a new group to create it

Classroom groups and GitHub teams

When students join their group in Classroom, a team is created on GitHub.com in your GitHub organization. Teams have pretty nifty functionality, including threaded comments and emoji support.

If you create a team for your students on GitHub.com, that team will not appear in Classroom. If you’d like to use Classroom to distribute shared repositories, then use group assignments in Classroom, not teams on GitHub.com.

When you use group assignments in Classroom, each team of students will get access to one shared repository for the exercise. Every student will be able to push and pull to their team’s repository. We recommend assigning one student per team to act as project manager to resolve conflicts or merge pull requests. If your students are new to resolving conflicting changes, they can check out our documentation to learn to manage merge conflicts.

Get deeper insight into group participation

Once your students are sorted into teams, they can start collaborating on the assignment like they would in any other repository: by pushing commits and branches, opening and reviewing pull requests, or using issues. Similarly, all of their commit history is available for you to review.

As students finish up their assignments, you can see the work they’ve done in two ways. Examine the current state of the files to see the finished product or look through the repository’s history to see how students worked together. GitHub’s “Insights” tab provides you with a picture of how your students worked together. For example, “Pulse” data gives you a timeline of your students’ pull requests, issues, and conversations, while “Contributors” graphs visualize your students’ additions and deletions.

Once students complete their projects, there are a few ways to deliver feedback, including:

• Going to the list of commits and making comments on individual commits
• Weighing in on a per-line basis (if students used pull requests)
• If you find that students make a similar error over and over, creating a canned reply and opening an issue directly from the plus sign (“+”) in the code view

If you chose to use private repositories for your assignment, your feedback will be confidential, so only you and the students in the group will see it.

Create a group exercise

Ready to give a group assignment? Get started right away in GitHub Classroom. Or check out this discussion in the GitHub Education Community on how student groups can work with GitHub teams in Classroom.

To support teachers who want to master GitHub, we’ve launched Campus Advisors—a training program built to help you commit with confidence and teach your students with real-world tools.

Our inspiration for the training comes from the teachers in the Education Community who innovate in their courses, help each other with recommendations, and contribute to open source projects.

The teachers out there never fail to amaze us. We’ve seen Taichi Furuhashi build a GIS course support Red Cross relief efforts, Mine Çetinkaya-Rundel use open source to nurture reproducible research, Dan Wallach contribute scripts back to the community, and so many more examples of teachers doing impactful work. We’ve worked with hundreds of these passionate educators to create the curriculum for GitHub Campus Advisors.

Teacher training to master Git and GitHub

Over the past few years we’ve seen version control take hold in statistics, biology, ecology, libraries, and journalism departments, in addition to a becoming a standard in computer science and engineering courses.

One of the most common questions we hear from these teachers is “How do I use Git and GitHub?” We’ve seen the magical things that teachers do with GitHub, and we want to help.

The Campus Advisors training directly addresses classroom use and the needs of teachers in four modules:

1. Git basics: understand how Git works so you’re better prepared to help your students when they get stuck
2. Individual work: create, distribute, and collect coding exercises for your students to complete individually using GitHub Classroom
3. Group work: strategies for creating group learning experiences that parallel real-world software development and techniques to understand individual contributions to group projects
4. Student programs: opportunities for you to encourage self-directed technical education outside the classroom

All of these modules are online and available fo you to take at your own pace. Once you complete the last exercise, you can apply to become a certified GitHub Campus Advisor.

Support other teachers at your school

As a GitHub Campus Advisor, you’re not only an expert in Git and GitHub. You also champion the use of real-world tools at your school and help teachers new to GitHub use version control.

If you’re passionate about implementing new technologies at your school, or active in your continuing education community, get certified as a GitHub Campus Advisor and we’ll equip you with workshop materials, and custom goodies to show the world your expertise.

Start the training

Special thanks to all of the teachers who weighed in with the 2017 classroom survey, the folks who gave feedback at GitHub Universe: Teacher Day, and the teachers and librarians at Duke University who tested the curriculum in-person.

In the third programming course in the computer science major, Dan Wallach wants students to master programming in Java with a high degree of rigor and at a large scale. This past semester in his Comp215 course, he chose to use Java8, IntelliJ, and GitHub to implement a test-driven development workflow.

Teaching concepts with a long shelf life

Wallach sees three supporting “ladders” at work in his curricula: Java programming, software design, and tools like Checkstyle, Error Prone, Gradle, and GitHub.

Wallach encourages his students to focus less on specific tools and more on their fundamentals. “I want to teach ideas and concepts that’ll have a long shelf life. So 10 years from now, is IntelliJ going to be the thing? Is Java even going to be the thing? Probably not,” he said. “But mapping a function over a list to get another list, that will be there 10 years from now.”

Moving from Subversion to GitHub with Travis CI

Dan was looking for a scalable, reliable solution for his course: In 2015 the peak loads from his students’ work crashed their campus Subversion server, forcing them to extend their deadlines and ultimately run a private server, requiring significant assistance from Rice’s IT group.

He decided to move to GitHub and use GitHub Classroom in the fall of 2017.

I had confidence that GitHub would make sure their service would be up and available. Their commercial business depends on high uptime.

Dan used GitHub Classroom, a teacher-facing tool that enables the GitHub workflow for courses, to distribute assignments, and Travis CI to run unit tests.

I was initially worried that the complexity of Git would be a pain point for my students. As an example, I was afraid of having to explain to a student what a “detached HEAD state” might be. In practice, this was never an issue. We steered students to using IntelliJ’s front-end for Git, keeping them from getting into too much trouble. It’s a nice bonus that students can visit the web page for their repo and double-check that everything was correctly pushed.

An example of distributing an assignment through GitHub Classroom and tests through Travis CI.

Nurture collaboration through filling in holes

As the semester progresses, his students get better at “filling in holes,” Wallach said. Initially, Wallach provides his students with code that has missing pieces.

After they fill in those holes with their own code, he introduces a more complex activity: Build an application from the library of code they’ve previously helped build.

“Every week builds on the previous week. I give you a bunch of code including a correct implementation of the prior week’s project, you write tests and add missing features, and then you submit it,” he explained.

Laying the groundwork for strong collaboration

Wallach has what he calls a “controversial” position on pair programming: He doesn’t use it in his classroom. He sees pairing as only one path to collaboration.

“Learning to use Git, from scratch, is hard enough without collaboration,” he said. He’d seen his students try to pair while learning Git:

“Hey, you didn’t push your changes.” “What? Yes, I did.” “Okay, now I’ve got a merge conflict.”

While that back and forth is a kind of collaboration, Wallach wants to set students up for success.

There’s plenty enough to learn about version control systems in a solo environment. Comp215 is many of our students’ first experience using development tools on their own computer, as opposed to in a browser. Partner-based collaboration with Git requires a more sophisticated understanding to deal with merge conflicts, pull requests, and so forth.

By having his students work by themselves first, Wallach prepares them with the habits and mental models for subsequent classes in the curriculum where they work in teams.

Contributing back to the GitHub Education community

Wallach built several scripts to help with his class workflow and shared them with the GitHub Education community. For example, Git takes its commit times from the clock on the students’ computers. When Wallach spotted a student attempting to use this to submit after a deadline—using his Travis CI/GitHub workflow which logs the time on Travis and cannot be forged by a student—he made a tool to produce a nice table with a given student’s commit times and GitHub’s push time.

Wallach encourages collaboration through his GitHub contributions and his classroom. And his groundwork has paid off. He often hears from past students that his class prepared them for a workplace environment. By teaching skills that have a long shelf life, Wallach’s students feel ready to collaborate in the long term.

Here are some of Wallach’s helpful contributions to the GitHub Classroom community of tools:

• A tool to clone every student repos at once
• Creating release branches for students
• A tool to print all of the “push” times for your students’ commits

Wilhelm Klopp is a student at University College London (UCL), a Campus Expert, and creator of Simple Poll—one of the most popular Slack integrations. He spent the summer of 2017 as a Developer Relations Intern on the GitHub Education team. In this post Wilhelm shares his work on GitHub Field Day over nine weeks at GitHub HQ in San Francisco.

Solving a problem for my own community

At UCL, our student community is vibrant and engaged, but after a few years, I noticed that we lacked a system for “knowledge transfer”, including a way for older leaders to train new students before they graduate. There are a few great resources out there to help solve this problem. Campus Experts, for example, is an online training community to enrich the technical community on your campus.

Personally, I was interested in developing an in-person event for student tech leaders—and GitHub Education was interested, too. For my internship, I proposed to start with a prototype event at GitHub HQ in San Francisco, and grow it to wider scale from there.

The event, later called “GitHub Field Day,” would bring together tech student leaders to learn from each others successes and mistakes, figure out what works and what doesn’t in community development, and get to know each other. Field Day would be an event where students create an agenda of their pain points and success stories. After a day of learning from each other, they could go back to their own schools and apply the lessons learned.

Support and mentorship, the GitHub way

The first week as a GitHub intern is big—kind of like moving to new city and starting a full-time job. You move into a flat in San Francisco, meet your co-workers, and get to know the team you’ll be spending time with over the summer. The Developer Relations interns also got to join the Education team for a “mini-summit”: a twice-annual team meeting where we discuss priorities and timelines, while getting a sense of how the team works together.

Something that not very many people know about GitHub is that over 60 percent of its employees work remotely. Although all interns are based in San Francisco, we worked remotely with our GitHub team members—sometimes across multiple time zones. This can be challenging at first as you learn to use a plethora of communication tools to their fullest.

For example, if your teammate lives in Scotland and you’re in San Francisco, you might get a few Slack messages outside of working hours—or even wake up to reminders about 4 am meetings.

Interns have on-boarding cohort, just like GitHubbers do–and complete with swag. Here’s the whole internship class in our navy GitHub Intern hoodies.

Launching the first Field Day

Fellow interns @jasonetco and @kim-codes and I worked quickly to gear up for a successful launch, which meant we needed branding, an announcement, and a landing page for the event. Together, we managed to get it all up and running in just five days. The morning of the event, we also put together banners, name tags, and enough food to feed dozens of students.

The hard work paid off: We received hundreds of applications from students who wanted to improve their communities, and on Field Day we had a packed house. When 50 students began to walk through the door, I knew we were onto something great—everyone was excited and had a lot to talk about.

One topic was learning design for coding beginners, particularly relevant to student-run events and hackathons. Another common pain point was how to develop a group identity, and make new members of a school’s tech community feel like they belong. Students also wanted to be able to connect their campus community with other schools, something they could accomplish through the relationships they built on Field Day. We even had a surprise visit from GitHub’s Senior Vice President of Technology, @jasoncwarner who did an impromptu Q&A.

I’m happy to share that Field Day lives on: all the work going into the branding, outreach, design and reflection has now shipped to 10 scheduled events around the world.

See if Field Day is visiting a city near you

Postscript shoutout: thanks @kim-codes!

Thanks to my awesome intern cohort and especially @kim-codes—my partner-intern in crime in brainstorming, ideation, and execution.

We’re just wrapping up application season for our 2018 internships. If you’d like learn more or get updates on recruiting for our 2019 intern cohort, visit internships.github.com.