Scholarly Git Experiences Part II: Git for Education

This post is a continuation from July's post on the notable ways in which scholars use Git hosting platforms (GHPs) to carry out their research and work. I focus on how educators, teachers, and instructors have incorporated GHPs into the classroom.

This chart maps the scholarly Git experiences discussed thus far. The white rows are those scholarly Git experiences covered in previous posts. The green row is what this post will focus on: Education!

Education, the cycle of teaching and learning, is a primary domain defining the scholarly experience and GHPs became a classroom tool after some trial and error. One of the earliest evidence of version control systems (VCS) mentioned within education (Larsén, 2019) came from Cornelius, et al. (1989) recounting a workshop on software maintenance best practices. Cornelius, et al. were disappointed when students did not make use of the given revision control system to debug the source code they were assigned for software maintenance practices. This prompted the researchers to focus more heavily on educating students about the importance of VCS as a fundamental tool in future software maintenance workshops. While this case was pre-Git, it started a VCS trend in academia, leading to GHPs as a tool to enhance educational experiences.

Fast forward to Laadan, et al. (2010), this is an early approach of a course on managing operating system development at Columbia University (Glassey, 2019). They saw opportunity in "using virtual appliances and distributed version control", by way of institutionally hosted Git servers and Linux kernel development environments for students. This was steering away from the traditional centralized computer laboratory facilities—providing students everything from loaning laptops to software. At this point, it was clear that the market for laptops and personal devices were more affordable and widespread, and future work environments were not bound to computer labs and centralized desktops (Laadan, 2010). The researchers and instructors were in search of cost-efficient solutions and more industry relevant experiences to give students. Trends toward education technology (EdTech) and cloud hosting Git environments lead us to what we see now: more scholars using GHPs as interactive education resources including syllabi, textbooks, assignments, and course management. Each of these will be addressed as separate categories in this post.

Syllabi on GHPs

In 2012, the ProfHacker blog published GitHub101, a series dedicated to the positive and negative experiences academics have experienced while integrating GHPs into their teaching and learning duties. Brian Croxall, Assistant Professor of Digital Humanities at Brigham Young University, contributed to the series by using the term "forking" when adopting and adapting open access syllabi in his Forking Your Syllabus article. In the context of Git, forking is:

a special form of replication on [GHPs] that retains a connection to its originating repository. . . press the 'fork' button on the top right of the repository's main page. It will then be copied to your own list of repositories. . . A link back to the original is shown whenever you navigate to your fork. . . [y]ou are not just saying, 'I could use what you wrote,' since a clone is sufficient for that purpose. You are saying, 'I could use your text and want to improve it'" (Lawson, 2013).

Croxall refers syllabus forking as an open syllabus, which is a form of an open education resource (OER), that is available to be retained, reused, revised, remixed, and redistributed (Wiley, 2014). Lincoln Mullen, Assistant Professor in the Department of History and Art History at George Mason University, further supported this in a follow-up post, How to Fork a Syllabus on GitHub. Mullen is known to post his syllabi as Markdown files on his website. E.g. American Scriptures course syllabus in a Markdown file saved in his GitHub repository—it has been forked once. There are more than 2,770 GitHub repositories and forty-four GitLab repositories including syllabi. Other notable examples of syllabi on GHPs:

1. The Nature of Code: "Intelligence and Learning" syllabus created and taught by Daniel Shiffman, Associate Arts Professor at New York University. It has been forked the most, 287 times, out of all syllabi in GitHub. This was determined by using GitHub's search bar, entering the term "syllabus", and sorting results by "Most forks". Shiffman's repository has nine open issues and twenty-one closed issues, which look like a mixture of To Do items from Shiffman himself and suggestions updates from external scholars.
2. This Introduction to Collaborative Social Science Data Analysis syllabus, from the Hertie School of Governance in Berlin, has been forked fifty-nine times. It has fifty-seven issues notifying authors, students, and other instructors of messages ranging from class date changes to access to the course book. There are other issue types offering great examples of education with GHPs, but those will be covered next in the section about course management.
3. While this is not ideal for version control, there is the option to upload a PDF of the syllabus directly into the GHP repository, such as Suman Khanal, Teaching Assistant at Tribhuvan University, has recently done in his BSc_Syllabus GitLab repository.

As Stanford University mentioned on their Undergrad: Cardinal Compass site, a "syllabus is a guide to a course. . . Syllabi are always subject to change, especially if a different instructor is teaching a course." Syllabi are dynamic documents, and hosting a syllabus on a GHP offers version transparency through each quarter/semester, which is particularly vital with the natural rotation of instructors in academia. GHPs built-in version control for syllabi benefit the future self, improve course materials choice, and display the evolution of course materials.

While "Githubbing a Syllabus" may not be for everyone, it is important to remember to provide appropriate attributions on forked syllabi. OER advocates promote the use of Creative Commons licenses, which promotes "provenance for ideas (always important in scholarship), generates goodwill among fellow scholars, and might even help make your case for the influence of your teaching innovations when it comes time for an annual or tenure review" (Croxall, 2012). This approach is positive progress for the OER movement as it gives scholars the opportunity to expand their curriculum and learning materials while creating a starting point for hosting OER materials in a collaborative environment.

OER on GHPs

Scholarship and research institutions fundamentally want to "further our missions to advance knowledge", and since "our systems of sharing knowledge no longer work in support of our academic enterprise", there has been significant adoption for open access (OA) and OER (Big Ten Academic Alliance, 2019). For example, last Spring, I took Introduction to Programming for my University of Washington MLIS program, and the textbook was hosted on GitHub using Bookdown, an open source R package written largely by Yihui Xie. Bookdown has its own instructional publication, bookdown: Authoring Books and Technical Documents with R Markdown, by Yihui Xie, RStudio engineer. Chapter 6.2 is a step-by-step guide on how to publish with Bookdown on GitHub Pages. As usual, the community of open source developers and maintainers excel in diversifying platform dependencies by creating additional instructions on publishing with Bookdown while hosting on GitLab. Documentation for Bookdown on Bitbucket is not as clearly defined, but is roughly available in the README of Foundations of Statistics book by Darrin Speegle and Bryan Clair, Saint Louis University Professors of Mathematics and Statistics. Each platform requires continuous integration to render the books for students, which will be covered in more detail later on in this post.

Publishing as a Git scholarly experience will be further reviewed in a later post, but similar to syllabi, textbooks, assignments, and supplementary learning resources are being hosted and disseminated on GHPs. Hosting OER on GHPs expands open scholarship efforts by allowing educators to access course materials, structure, and interface through GHPs version control, issue reporting, and forking features. As mentioned in July's post, version control allows provenance of the learning materials, collaboration and updates through issues, and replication and expansion through forking. Here are a couple courses that have published textbooks and materials for anyone to learn from, remix, or reuse for their own use:

• The Carpentries is a non-profit organization that has been "teaching basic lab skills for research computing" since 1998 ("software carpentry", n.d.). The Software Carpentry GitHub repository offers a variety of course content ranging command line, Python, SQL, etc.
• Vicky Steeves, IASGE Project Lead and Visiting Professor at Pratt Institute's iSchool, relies on GitLab to host a Data Librarianship course. This includes a syllabus, lectures, homework, and in-class activities. She offers a guide on how to contribute for those who can offer improvements.

Each of these OERs include instructional materials, assignments, schedules, syllabi, and lectures upon the flexible GHP frameworks. They can be retained, reused, revised, remixed, and redistributed.

Hosting Courses on GHPs

It's true—GHPs were not created as learning management systems (LMS), but nonetheless, there is significant evidence that instructors are actively harnessing GHPs to manage course materials and inspire interactions with/between students. As mentioned earlier, one of the first records of Git used in the classroom was published in 2010 (Glassey, 2019; Laadan, 2010). It took three years later for the first publication about the "benefits of using Git in coordination with hosting services that were cloud-based, rather than teachers needing to overcome the complexities of setting up local servers" (Lawrance, 2013). At the time, Lawrance, et al. further reviewed Assembla (it is unclear if the plan is still free), Bitbucket, and GitHub since those GHPs quietly offered free private repositories for educational use. One year later, and with 70,000 student accounts, GitHub publicly announced a special education community and free perks for students, educators, and educational institutions (Britton, 2014). Naturally, other GHPs followed suit.

Similar to the freemium models we've experienced in the past (e.g. Apple's colorful iMacs, Microsoft's Windows Office Suite, and Google's G Suite), many GHPs saw opportunity in educators and students hosting course materials on their platforms, and so, free unlimited repositories for students, teachers, and education institutions rolled out in GitHub, BitBucket, and GitLab, respectively. This was the rise of instructors incorporating GHPs into syllabi and assignments, naturally mostly in STEM (Hasselbring, 2019). Other theories on why GHPs have gained popularity in the classroom include its: "robust system for managing student course-work, sophisticated collaboration and communication tools for students and teaching staff, and an authentic experience of an important software engineering skill" (Glassey, 2019). It also helps that Git and GitHub have become "the de facto VCS tool/platform for open source projects" (Glassey, 2019).

Without a doubt, Github and GitHub Classroom have been the most popular GHP at the lunch table. GitHub Classroom was created by Mark Tareshawty. At the time of development, Tareshawty was a Computer Science Engineering Student and Teaching Assistant at The Ohio State University and current Ecosystems Engineer at GitHub, and he wanted a tool that could "significantly streamline the process [of managing students and assignments, wherein] teachers invite students onto GitHub and create and share coding assignments through the service" (Metz, 2015). This means a teacher can create a template repository with code and assignment instructions, then students on the roster can press a button that will automatically create "their own 'sandbox' copy" of the repository, creating a custom URL for the teacher to easily track and manage each students' individual repository. For classes of twenty or more students, this tool development was perfect to follow GitHub Education's free unlimited repository plan. Now, that GitHub Classroom is set up to sync with class rosters from popular LMS, course creation and administrative tasks will be even more seamless (Woodthorpe, 2019). Substantial community investment into GitHub Classroom is apparent as seen through the:

• Dedication from six named maintainers tackling ongoing issue tickets to make the tool service the needs of educators and students found in GitHub Classroom's README;
• Issue Tracker with more than 800 closed and more than 100 open tickets listing ongoing development and support for the platform, and
• 1,281 closed and twenty-five open pull requests (as of September 1, 2019) from users and contributors from all over the world.

While GHPs cannot fully replace LMS (i.e. due to administrative metrics and other out-of-the-box tools for a wider variety of instructors), transparency from GitHub Classroom ROADMAP, could give educators and institutions more confidence and understanding on how much they want to prioritize and/or invest in implementing future courses on a GHP platform.

Course Management on GHPs

After GitHub unleashed unlimited free repositories for teachers, one of the first publications (Glassey, 2019) noted specific benefits of using GitHub throughout the course highlighted: (1) secure submission, (2) underwriting provenance and derivation of submitted work, (3) better source file organisation, (4) integrated Issue Tracking, and (5) exposure to standard industry practice (Kelleher, 2014). This point of view offered detailed benefits to teachers' administrative tasks and to students' practical knowledge. Core functionalities of GHPs are expanded upon from several educators' case studies on teaching with GHPs and from various supplemental open source packages built by educators.

Popular GHPs like GitLab, BitBucket, and GitHub comply with Family Educational Rights and Privacy Act (FERPA) conditions through their "generous academic discount polic[ies]" (Cetinkaya-Rundel, 2017) by offering unlimited secure, private repositories for students and educational institutions. Meeting this requirement when adopting new technologies is key for educators and administrators as this ensures protection and privacy for students training to contribute to society and the workforce in the near future.

As GHPs are adopted into the classroom, there are two existing common management approaches: (1) one repository per student per assignment (ORpSpA)— for every given student, create a repository with identical contents to a master repository containing the assignment materials for a specific assignment. GitHub Classroom follows this approach. Then, (2) one branch per problem (OBpP)—each student has one repository, but many branches within that repository to store the solutions for their assignments (Glassey, 2019).

As expected from the open source community, there are a variety of supplemental programs to address the time-consuming administrative tasks that GHPs do not fulfill for education management, "such as distributing work assignments, gathering assignments for assessment, assigning peer review tasks, linking to third party tools to automate assessment tasks, and sharing feedback with students" (Larsén, 2019). Some were built to be standalone from GitHub Classroom (GHP-agnostic), while others are built to bolster existing GHP education environments. All the while, safety of FERPA requirements are met. A couple examples include:

1. ghclass: This open source R-based tool was authored by a team of associate professors at Duke University (Rundel, 2016) to create a classroom management environment that uses R with GitHub. They wanted "to provide a practical computational foundation for students. . . while minimizing frustration and improving adoption for both our students and instructors" when teaching and learning RStudio, R Markdown, Git/Github, Unix/Linux, and continuous integration (Rundel, 2017; Fiskel, 2018; Bryan, n.d.). The curriculum of concepts and tools that statistics students needed to fulfill learning requirements. With ghclass, teachers could expose students to GitHub, as well as control student access permissions and minimize "accidents that cannot be undone and [make] sure students cannot peek into each others' repositories unless you explicitly allow them to do so" (Rundel, n.d.). It has similar features already offered in out-of-the-box GitHub Classroom, such as creating repositories per student, assigning students to each repo, creating teams per assignment, modifying assignments, and collecting student work within the repos. On the ghclass FAQ page, the authors carefully distinguished that ghclass offers pre-defined assignment teams, command-line interface with R to solve issues, and that ghclass and GitHub Classroom can be used simultaneously for robust functionalities. This demonstrates the flexibility between open source programs that educators cannot normally get from commercial LMS.
2. RepoBee is another open source tool that helps educators streamline GitHub and GitLab for course materials. Researcher, Simon Larsén, and Lecturer, Richard Glassey, at KTH Royal Institute of Technology created RepBee in order to maintain assignment dissemination and ingest, peer review, feedback, third-party tools, "a simple command line interface, document itself for teachers rather than software engineers, and expose a basic interface for extension in order to fit specific course needs" (Larsén, 2019). While it does not include automatic grading nor a GUI for teachers, Repobee has twelve commands that lets teachers make batch actions.
   1. setup, update, and clone initiates the bulk of managing students' repositories (i.e. assignments)—creating repositories for each student, pushing template repository code into the students' repositories, updating assigned repositories, and cloning a student repository to add corrections. The ability to perform this in batch gives teachers more time to manage student questions and issues.
   2. Issue management includes a few sensible commands for teachers to open-issues, close-issues and list-issuesinstead of having to go to the GHP web browser interface. This is convenient for those who are comfortable filtering through issues using regular expressions.
   3. And last, is peer review management which allows the teacher to create review teams for other student repositories with read-access only: assign-reviews. RepoBee's team grouping and repository assigning algorithm saves time from manual team creations. More on the actual perks of team assessment and peer review will be flushed out in the next section about collaboration, communication, and feedback.

Other GHP compatible tools that are worth checking out: ACAD, Gitomator, Rhomboid, Submit50, Teacher's Pet (archived and read-only now), ArTEMis, and Virtual Classroom (Larsén, 2019).

Collaboration, Communication, & Feedback

Now that the common GHP-hosted course management workflows have been established, I want to go into the advantages of using GHPs for student and teacher benefits. First off, GHPs facilitate enhanced collaboration and communication between student peers and immediate feedback between student and teacher, particularly for distance-learning courses. There is evidence that "teamwork [through GHPs] had encouraged these students to improve their development skills" (Raibulet, 2018).

The most basic approach to communicating assignments and announcements from teacher to student is through the README or Wiki page, which each GHP repository normally features as source documentation. Shiffman included assignments, presentations, and other resources on his Nature of Code: "Intelligence and Learning" course Wiki page. Students will be able to refer to the course Wiki on the GHP for centralized assignment information, alongside the syllabus.

Teacher-to-student (and vice versa) feedback, questions, and announcements can be delivered through Issue Trackers on GHPs, "where the feedback captured in the issue tracker could be used to better understand individual assignments as well as differences in teaching assistant behaviour" (Glassey, 2019). This is similar to the Community & Collaboration section in July's post, but managing issues and threads across repositories can get unwieldy when there is a class of thirty students and participation in discussion via Issues is worth 15% of their overall scores. With tools like RepoBee, teachers can monitor peer reviews and push assignment updates and announcements to each individual student repository for class notifications (Larsén, 2019). Peer review management, within RepoBee, first sets up randomized team-pairs between students. This is done through a custom algorithm, grouping students together to review each others' assignment submission and then opening up discussion between the peers (Larsén, 2019). Students submit reviews as an issue and teachers can see if students' have seen the review through check-review. "This functionality is not robust enough to use peer review as a graded task itself, as there are ways students could fool it" (Larsén, 2019), but this offers transparency and a dedicated channel for students to learn from each other.

Another option to communicate feedback and suggestions is through pull requests. Pull requests are built into GHPs to organize and offer a discussion channel for "proposed changes before integrating them into the" development workflow (Making A Pull Request). In the case of GHPs for education, pull requests are a repurposed way for students to share and collaborate suggestions to other student or teacher repositories. Line-by-line comments can be made in the GHPs pull request interface, giving students the space to talk about their work similar to software development teams. Professor Kertész at Transilvania University found "instant feedback on code (either from the teacher or from colleagues) also led to an increase of code quality in the homework of the students. Compared to previous years when exercises were solved individually as homework assignments and evaluated during laboratory sessions, the code proved to be much better, leading to better grading for the homework part." Surprisingly, students also began to engage with the syllabus by giving feedback and submitting pull requests for new material suggestions (Kertész, 2015). This interaction between students and teachers is also detailed on GitHub's blog: How to use pull requests in the classroom.

The third approach to open communication and efficient assignment management on GHPs is "the use of a continuous integration framework that runs testing automatically when students push their work, highlighting the extensibility of this platform" (Glassey, 2019). Traditionally, continuous integration (CI) has been used by software development teams to "detect defects and failures in programs" (Krusche, 2018), especially useful when executing new feature builds. With the influx of programming courses and students, manual assessment of students' code is no longer viable—teachers and teaching assistants are utilizing free automated testing suite services to help monitor and provide feedback to student submissions. With CI, this real-time feedback for teachers and students opens up opportunity to iteratively check and improve the coding process before and after assignments have been submitted (Gennarelli, 2017).

CI for assignment feedback is not included out-of-the-box within GHP course repositories, but it is freely available from services like Travis CI (a third party service that can connect to GHPs) and GitLab CI (integrated into each GitLab repo) in efforts to support the Git classroom environment. There is also a solid support system to make integration and set-up as well-documented and (hopefully) as simple as possible. Shane Wilson, Professor at Ulster University, reports how the YAML configuration file (.travis.yml and .gitlab-ci.yml) in a GHP repository holds the script that test for students pushing assignments. This feedback loop gives students the opportunity to receive iterative feedback, without instructor intervention, instead of one uninformative error at the end of the assignment, hours before the code is due (students and procrastination will always co-exist) (Cetinkaya-Rundel, 2017). "In the past, only 51 percent of students passed the coursework after the first assignment. When GitHub Classroom and Travis CI were added to the mix, the passing rate rose to over 87 percent" (Gennarelli, 2019).

Mike Zamansky, Professor at Hunter College, published a blog post and video about his experience setting up Travis CI with his GitHub Classroom account. Alongside his own tutorial, Omar Shaikh, Lecturer at San Francisco State University, notes how the automated tests highlight where students are struggling, pinpointing stages where style and composition need help instead of "without getting bogged down explaining syntax issues" (Gennarelli, 2017). While there has been reported success with CI, it is crucial to remember that this does not save graders from manually checking for plagiarism or bad coding style. Despite the continuous manual work and a case of students reporting negative experiences when using GHPs for their computer science 1 course, they still found that the GHP's ability to "automatically triggering evaluation whenever a student pushed their work" was still a notable beneficial feature (Biňas, 2013; Glassey, 2019).

Provenance of Materials & Submitted Work

A feature of transparency and feedback communication in GHPs is that it also keeps the provenance of submitted work—"the origin or source of something" (provenance). Version control keeps the history of changes to a file, tracked using Git. This provides greater transparency on the derivation of students' work for iterative feedback, as well as provide flags for plagiarism. "[T]he sudden appearance of an established solution as a single commit [can serve] to draw attention to the submission" (Kelleher, 2014). Many developers may follow the mantra "commit early, commit often" (Harpp, 2016; Worklytics, 2016), which can be helpful for student work and teacher feedback. When a student is able to commit and push their progress to a GHP, teachers are able to scan for students' progress. While this is especially relevant when continuous integration is implemented (Gennarelli, 2019), the time it takes for CI to re-run all of the codebase will require some patience. Furthermore, the ability to see the changes within the submitted work in smaller chunks is aligned with behavioral practices in work environments.

Challenges When Incorporating GHPs

As with all technology, GHPs for education is not all sunshine and roses. Educators will run into roadblocks with GHPs as their LMS:

"[D]espite this strong trend, the adoption of a VCS into a course depends on the teacher's confidence and ability to use the technology in a pedagogical context. For teachers who use a VCS as part of their normal practice, it is still a step up to administer potentially thousands of repositories for students who depend upon them for completing their assignments or projects" (Larsén, 2019).

A misconception that new computer scientists might have when learning Git while learning, say, programming for the first time, is confusing the two programmatic concepts and "hav[ing] had a badly formed mental model of version control, confusing branches with files and folders" (Isomöttönen, 2014). I saw this in my own Intro to Python course where classmates conflated Bash in command line with Python since they were being taught and used simultaneously. According to Raibulet (2018), students claim they will use GHPs in future software projects but also found that "they also discovered that they lacked understanding about the system or having confidence in their ability to use it effectively beyond the course" (Glassey, 2019). This was due to challenges like "(1) the perils of public projects, (2) unfamiliarity with Git and Github, (3) notification overload" (Glassey, 2019).

These types of challenges and issues that students and teachers have with GHPs is part of the larger research question we ask within the IASGE team. With "[n]early 20,000 teachers use GitHub Classroom to manage coding assignments and automate repository creation" (Woodthorpe, 2019), it is clear that scholars and GHPs are investing resources to use and improve the platforms. We want to understand why scholars do or do not adopt GHPs into their education and research workflows after learning the basics of GHPs. What are the major roadblocks to making use of Git and GHPs, and what convinces others to adopt and continue with them? Isomöttönen (2014) had a supporting research topic that stemmed from their original findings: "how effective the students can use the system and how the organization of the group work influences the use of the system. It might be that some students know very well how to use the system, but do not see any reason to use their skills up to a full extent in the given settings."

My next posts will cover the last four notable ways in which scholars use GHPs, such as for data quality assurance and reproducibility. As mentioned in previous posts, these IASGE updates are active conversations while I continue my research about the scholarly Git experience. We encourage questions and further research suggestions. Please feel free to submit an issue or merge request to our GitLab repository or email Vicky Steeves and/or me to continue the conversation.

Bibliography

Big Ten Academic Alliance. (2019, June 10). Sustaining Values and Scholarship: A Statement by the Provosts of the Big Ten Academic Alliance [Statement letter]. URL: https://www.btaa.org/docs/default-source/default-document-library/sustaining-values-and-scholarship.pdf?sfvrsn=5cc449f3_6

Biňas, M. (2013). Version Control System in CS1 course: Practical experience. 2013 IEEE 11th International Conference on Emerging ELearning Technologies and Applications (ICETA), 23–28. https://doi.org/10.1109/ICETA.2013.6674398

Cetinkaya-Rundel, M., & Rundel, C. W. (2017). Infrastructure and tools for teaching computing throughout the statistical curriculum. https://doi.org/10.7287/peerj.preprints.3181v1

Cornelius, B. J., Munro, M., & Robson, D. J. (1989). An approach to software maintenance education. Software Engineering Journal, 4(4), 233–236. https://doi.org/10.1049/sej.1989.0030

Feliciano, J., Storey, M.-A., & Zagalsky, A. (2016). Student Experiences Using GitHub in Software Engineering Courses: A Case Study. Proceedings of the 38th International Conference on Software Engineering Companion, 422–431. https://doi.org/10.1145/2889160.2889195

Glassey, R. (2019). Adopting Git/Github Within Teaching: A Survey of Tool Support. Proceedings of the ACM Conference on Global Computing Education, 143–149. https://doi.org/10.1145/3300115.3309518

Hasselbring, W., Carr, L., Hettrick, S., Packer, H., & Tiropanis, T. (2019). FAIR and Open Computer Science Research Software. ArXiv:1908.05986 [Cs]. URL:http://arxiv.org/abs/1908.05986

Isomöttönen, V., & Cochez, M. (2014). Challenges and Confusions in Learning Version Control with Git. In V. Ermolayev, H. C. Mayr, M. Nikitchenko, A. Spivakovsky, & G. Zholtkevych (Eds.), Information and Communication Technologies in Education, Research, and Industrial Applications (pp. 178–193). Springer International Publishing.

Kelleher, J. (2014). Employing git in the classroom. 2014 World Congress on Computer Applications and Information Systems (WCCAIS), 1–4. https://doi.org/10.1109/WCCAIS.2014.6916568

Kertész, C. (2015). Using GitHub in the classroom - a collaborative learning experience. 2015 IEEE 21st International Symposium for Design and Technology in Electronic Packaging (SIITME), 381–386. https://doi.org/10.1109/SIITME.2015.7342358

Laadan, O., Nieh, J., & Viennot, N. (2010). Teaching Operating Systems Using Virtual Appliances and Distributed Version Control. Proceedings of the 41st ACM Technical Symposium on Computer Science Education, 480–484. https://doi.org/10.1145/1734263.1734427

Proceedings of the 2019 ACM Conference on Innovation and Technology in Computer Science Education, 534–540. https://doi.org/10.1145/3304221.3319784

Lawrance, J., Jung, S., & Wiseman, C. (2013). Git on the Cloud in the Classroom. Proceeding of the 44th ACM Technical Symposium on Computer Science Education, 639–644. https://doi.org/10.1145/2445196.2445386

Raibulet, C., & Arcelli Fontana, F. (2018). Collaborative and teamwork software development in an undergraduate software engineering course. Journal of Systems and Software, 144, 409–422. https://doi.org/10.1016/j.jss.2018.07.010

Rivard, C. (2019). Turning Archives into Data: Archival Rhetorics and Digital Literacy in the Composition Classroom. College Composition and Communication, 70(4). URL: http://www.ncte.org/library/NCTEFiles/Resources/Journals/CCC/0704-jun2019/CCC0704Jun19Turning.pdf

Rundel, C., Çetinkaya-Rundel, M., & Anders, T. (2016). Tools for managing classroom organizations [R]. URL: https://github.com/rundel/ghclass

Sample, M. (2012). Git a Fork in My Syllabus, It's Done. Retrieved April 25, 2019, from ProfHacker: Teaching, tech, and productivity. URL: https://www.chronicle.com/blogs/profhacker/git-a-fork-in-my-syllabus-its-done/40331