Applying GitHub Services to Support Teaching-learning Strategies

in Computer Science Courses

Manel Mena

, Javier Criado

, Isabel M. del

Aguila

Joaqu

ın Ca

nadas

and Luis Iribarne

Department of Informatics, University of Almer

ıa, Spain

Keywords:

GitHub, Classroom, Feedback, Automation, Tests, Teamwork Collaboration.

Abstract:

Computer Science students need to acquire both theoretical and practical use of the knowledge that is covered

by the subjects or courses of their degrees. However, sometimes they attend lectures about theoretical concepts

that they cannot apply with real development tools that are part of the industry. Therefore, we believe that

students have to start working as soon as possible in a similar way to the one they will use in their work once

they have ﬁnished their studies, considering each course or each deliverable activity as a software development

project. This paper describes the solutions adopted and applied to ﬁve Computer Science courses in two

innovation teaching projects of the University of Almer

ıa. Furthermore, we present a series of support teaching

tools for managing and creating GitHub projects as GitHub is the core technology for developing teaching-

learning activities because of its widespread use. Each course manages its own strategy according to its speciﬁc

characteristics (i.e., learning objectives, number of students, schedule or programming languages).

1 INTRODUCTION

Computer Science courses should provide not only

both solid theoretical and practical foundations in

many knowledge areas, but also teamwork to prepare

the students for their careers (Gutica, 2018). Besides,

with the demands of technological advances in soft-

ware, it is required that software development teams

work in a collaborative way, skills that every student

must learn from the very beginning in their Computer

Science courses (CC2020 Task Force, 2020).

Nowadays, one of the most widely used cloud

services to store collaborative software artifacts is

GitHub. GitHub is an online repository support plat-

form for managing projects and controlling code ver-

sions, reaching the social network level designed for

developers because millions of people worldwide use

its services to cooperate on it. It offers distributed ver-

sion control and source code management functional-

ities, plus its own features and integrations with many

external applications. It also provides access control

https://orcid.org/0000-0003-1084-8489

https://orcid.org/0000-0002-8035-5260

https://orcid.org/0000-0001-9896-7196

https://orcid.org/0000-0001-5391-965X

https://orcid.org/0000-0003-1815-4721

and several collaborative services such as feature re-

quests, tasks management, code merging or continu-

ous integration.

We believe that the students should start as soon as

possible to work with this kind of platform daily, that

is like they are going to work as engineers once they

ﬁnish their studies. This work shows the solutions

adopted for the embedding of GitHub in the learning

processes of several courses for the Computer Sci-

ence discipline at the University of Almer

ıa (UAL).

Each one manages their own strategy and takes ad-

vantage of the speciﬁc features of GitHub according

to the semester it is scheduled and the particular learn-

ing objectives deﬁned for the course.

The goal of this work is to develop strategies and

methodologies based on GitHub where the steps fol-

lowed by the students in the execution of the different

courses activities are linked with the steps of a soft-

ware development process. The approach is under

evaluation, and the proposed strategies have been in-

stantiated in the courses described in this article from

different perspectives. In some courses, the matu-

rity level in the use of GitHub services is higher than

in others, as well as the number of applied features.

Thanks to the involved innovation teaching projects,

an effort is being made to unify the strategies estab-

lishing a common methodology.

Mena, M., Criado, J., Águila, I., Cañadas, J. and Iribarne, L.

Applying GitHub Services to Support Teaching-learning Strategies in Computer Science Courses.

DOI: 10.5220/0011071000003182

In Proceedings of the 14th International Conference on Computer Supported Education (CSEDU 2022) - Volume 1, pages 289-296

ISBN: 978-989-758-562-3; ISSN: 2184-5026

289

2 GitHub SERVICES FOR

CLASSROOM MANAGEMENT

Nowadays, GitHub is the most popular Web-based so-

cial code sharing service in the software industry, and

many companies in technology areas use it

. It is not

only used to develop software and to write technical

documentation, but also to collaborate in a variety of

domains (Feliciano et al., 2016).

One of these soaring knowledge-area that exploits

GitHub services is education, speciﬁcally for Com-

puter Science courses that involve software develop-

ment (Zagalsky et al., 2015; Tushev et al., 2020) and

programming (Angulo and Aktunc, 2019; Glazunova

et al., 2021), but other disciplines have also deployed

successful solutions (Fiksel et al., 2019; Nelson and

Ponciano, 2021).

Just from the boost of WWW in the mid-nineties,

online facilities had been applying to support teach-

ing. Those software tools allowed teachers to host

and distribute the material to their students and fa-

cilitated interrelationships through emails and forums

threads. Learning Management Systems (LMS) such

as Canvas, Moodle or Blackboard were groundbreak-

ing tools still widely used today. These tools estab-

lished a new milestone in education because they pro-

vide instructors with various services for managing

and administering courses.

The features offered by LMS are evaluating stu-

dents, evaluating courses and instructors, creating

class discussions, creating computer-based instruc-

tion, and so on (Malikowski et al., 2007). How-

ever, while these tools allow communication between

teachers and students, they do not promote collabo-

ration because both roles are separated. GitHub goes

a bit further because besides enabling future profes-

sionals to learn how to manage and collaborate on

their software development projects, its services allow

teachers to deﬁne innovative teaching-learning pro-

cesses that can be customized according to speciﬁc

characteristics of their courses. We have deﬁned ﬁve

categories of supporting areas that have been instanti-

ated in the different courses described in Section 3.

2.1 Supporting Shareable Material

The most usual approach to sharing course contents

in this kind of platform is to include the documents

and material in a speciﬁc repository giving access to

the enrolled students.

Public repositories offer the possibility to share

content publicly without any access restrictions. On

GitHub Octoverse – https://octoverse.github.com/

the other hand, private repositories enable sharing

contents only to enrolled students, to students and

teachers, or only between teachers, giving desired

users the proper access to the repository.

However, were an entire repository to be shared,

for instance, a software tool, this approach would not

be valid. A better solution is to deﬁne an organization

that could support the different materials arranged in

several repositories. The deﬁnition of an organization

also facilitates the use of GitHub Classroom.

Besides the deﬁnition of an organization to sup-

port a given course, multiple teaching resources and

reference material on can be shared using GitHub.

Speciﬁcally, the feature called GitHub Pages makes

it easy and free to publish a static website hosted as

“. github.io”. This feature has been the starting point

to release several teaching resources to promote the

use of serious games

or to share coding problems as

learning objects (

Aguila et al., 2021).

2.2 Project Management

GitHub collaborative features can be leveraged during

the entire life cycle of a project. One of the most crit-

ical stages in software development is project man-

agement, and GitHub provides the Projects view for

this goal. For example, it is possible to create project

boards with a Kanban style (Malakar, 2021) and link

the task written on the board with issues related to

project development. Furthermore, issues can be de-

scribed with additional information (e.g., relevance,

priority, or related milestones) and assigned to spe-

ciﬁc collaborators. Finally, the status of the task and

issues can be tracked and managed.

This way, project management activities can be

applied to support the activities assignment, the track-

ing and monitoring of the exercises, as well as the

analysis of the learning objectives that users are

achieving (e.g. using the milestone concept).

2.3 Collaborative Working

Once the project scope has been identiﬁed in the man-

agement stage, each functionality will be managed

and implemented (i.e., solved). In a teaching-learning

process, this work execution can be analogous to the

moment the students build the solutions to the prob-

lems presented. In Computer Science courses, the

collaborative work includes the development of dif-

ferent artifacts involved in the course, for instance,

the speciﬁc solutions or reports for students’ assign-

ments or the software components that are part of a

software application.

Serious Games Repo – https://cutt.ly/TIO98SI

CSEDU 2022 - 14th International Conference on Computer Supported Education

290

Some exercises have to be solved individually, but

others require forming teams or working groups that

can solve a problem collaboratively. In this sense,

GitHub provides the necessary infrastructure, allow-

ing (i) assignment of issues to several students, (ii)

repository sharing, (iii) forks to build alternatives, (iv)

merging mechanism to gather partial solutions from

different students, and (v) reporting of contributions

by author, among other possible features.

2.4 Guidelines and Patterns

When students start to develop a solution for an exer-

cise, especially when it is related to courses of the ﬁrst

academic years, they need to receive frequent feed-

back and speciﬁc information about the exercise they

are solving. Therefore, it is not enough to make gen-

eral and theoretical contents available for them, be-

cause their application could be difﬁcult.

GitHub provides two approaches that can be used

for this purpose. The direct strategy is related to creat-

ing help content in the form of incomplete solutions or

templates that can and should be reused by students.

Teachers can create repositories to provide these tem-

plates so that users can clone them and have this set

of guides available to them. Another option is for stu-

dents to start directly by forking these repositories,

then developing their speciﬁc solutions and pushing

them in a new repository or as a pull request of the

original one.

The indirect strategy relies on the application of

continuous integration and continuous deployment

(CI/CD) processes to run validation tests on the ma-

terial pushed to the repositories. The application of

automated testing helps the students progress and en-

ables early error detection. Moreover, the feedback

information provided from the test executions can

be used as the guidelines to solve the corresponding

tasks, and the guidelines deﬁne a set of good prac-

tices that help transmit (teachers) and acquire (stu-

dents) patterns related to software development. This

strategy can be achieved using different alternatives

such as GitHub Classroom autograding, GitHub Ac-

tions, Jenkins, or GitLab CI/CD.

2.5 Support Teaching Tools

In Section 2, we have identiﬁed the different ways

in which we use GitHub. To support those different

purposes, we have developed an application (ITSI-

GITSI) for the generation and automatic management

of course repositories on GitHub that allows us to per-

form a series of repetitive tasks around functionality

offered by GitHub. Among the features of the appli-

1 apiVersion: 1

2 op: create

3 org: ualits

4 metadata:

5 repos:

6 -

7 name: "test2"

8 users:

9 - "javicriado"

10 - "manelme"

11 private: false

12 labels:

13 -

14 name: "1"

15 description: "low difficulty issue"

16 color: "ededed"

17 milestones:

18 -

19 title: "FirstMilestone"

20 description: "A milestone for the repository"

21 issues:

22 -

23 title: "Prueba1 test1"

24 description: "Issue description"

25 labels:

26 - "1"

Listing 1: Conﬁg ﬁle for repository creation.

cation, we have the following:

• Automatic generation of students’ and teachers’

repositories in a speciﬁc organization.

• Bulk generation of repositories using a .csv ﬁle.

• Generation of issues and milestones related to

course assignments, either when creating a repos-

itory or a posteriori.

• Calculator of scores for the users of the reposito-

ries, taking into account the issues resolved, either

simply counting one by one the issues or using

possible score tags of the particular issue.

• Automatic modiﬁcation of a markdown ﬁle to

capture the scores.

• Fast deletion of multiple repositories.

This application uses some conﬁguration ﬁles to

execute the different named functionalities . The

tool executes the conﬁguration ﬁle passed in the pa-

rameter. This ﬁle has to be in .yml format. In it,

we establish the functionality to be executed and the

conﬁguration parameters for that functionality, using

the paradigm known as conﬁguration as code (CaC)

(Rahman et al., 2018). As an example, the Listing 1

reﬂects the proposed conﬁguration for the creation of

a repository. In the listing, we can see how in line 2,

we establish the operation, in this case, create. In line

3, we deﬁne the organization where the repositories

will be created. A posteriori, we enter the metadata

of each of the repositories that will be created (lines

4-26). Moreover, inside this metadata, we deﬁne the

repositories themselves (lines 5-11), the possible la-

bels (lines 15-16), the milestones of the project (lines

Applying GitHub Services to Support Teaching-learning Strategies in Computer Science Courses

291

17-20) and the issues to which we can assign the la-

bels and milestones previously created. In the ITSI-

GITSI

public repository, we deﬁned a series of ex-

amples with the possible operations to be executed,

as well as the requirements of the application.

3 EXPERIENCE IN COURSES

As part of the work of the teaching groups, the strate-

gies described in Section 2 are being applied in dif-

ferent Computer Science courses. Table 1 shows the

strategies applied in the involved courses (from sev-

eral degrees and semesters). This section describes

the speciﬁc actions carried out for each of these

courses and analyzes some of the results obtained.

3.1 Software Engineering

The course Software Engineering allowed us to apply

a different perspective to the common use of a GitHub

repository. Normally, a repository is intended for ver-

sion control of the source code ﬁles of a software sys-

tem. However, in the Software Engineering course,

this type of source ﬁle is not needed because the main

objective is to teach students to model software sys-

tems using Uniﬁed Modeling Language (UML) (Seidl

et al., 2015) use case, class and sequence diagrams.

With this aim, students receive the system speci-

ﬁcations that they have to model, and build the cor-

responding UML diagrams. From these diagrams,

students generate the UML models in an XML-based

format that can be managed by the version control of

GitHub. In addition, the UML models uploaded to

the repositories can be automatically checked by ex-

ecuting a continuous integration process with Jenkins

(Smart, 2011).

Following this approach, we developed a Domain-

Speciﬁc Language, or DSL (Gronback, 2009), with

two objectives: (1) describe the infrastructure of

GitHub repositories and Jenkins jobs for each student,

and (2) describe the internal structure of the tests ap-

plied to the diagrams. Using this language, we can

automatically generate the required infrastructure for

the assessment of UML models (Criado et al., 2020).

The proposed workﬂow of the teaching-learning

processes is described as follows. Starting from a

problem speciﬁcation, teachers will generate a model

with the tests (considering the optimal solution for

each required UML diagram) that have to be exe-

cuted. This model is used for generating the JUnit

tests (Ammann and Offutt, 2016) that will be exe-

ITSI-GITSI - https://github.com/ualits/itsi-gitsi

cuted when the models constructed by the students are

pushed to their repositories. The results of test execu-

tions provided by Jenkins will be analyzed by the stu-

dents for evaluating the correctness of their solutions.

These steps will be repeated until the students consid-

ers that the solution is correct, i.e., the tests have been

passed, and the speciﬁcation has been fulﬁlled.

As a summary, GitHub has been used with the fol-

lowing perspectives. In the ﬁrst place, teachers use

repositories to share and manage the course mate-

rial. Secondly, the students repositories are used for

the collaborative development of UML diagrams and

models. And third, the feedback obtained for the tests

executions should be used as the guidelines to under-

stand which modeling directives and design patterns

have to be applied from the speciﬁcations.

In the next Software Engineering courses, we are

planning to use the GitHub project view to (a) as-

sign the exercises to the accomplished by students,

(b) track the progress of these exercises, and (c) au-

tomatically score the ﬁnished exercises by updating

the description for each student’s repository. Further-

more, GitHub actions features are being evaluated to

run the automatic process of checking UML models

stored in students’ repositories. This would remove

the necessity for using an external tool like Jenkins

for such tasks, simplifying the supporting infrastruc-

ture in the course.

The application of this approach in the Software

Engineering course is providing positive results. Dur-

ing the current academic year (2021-2022), a high

percentage of students have used this proposal to im-

prove their modeling skills. Of 165 students, 107

passed all the tests (65%). Of those who passed all

the tests, 63 passed the subject’s ﬁnal exam, for which

they had to apply the acquired modeling knowledge.

This is a 58% from the set of the students passing the

tests, and a 38% from the total of students.

3.2 Software Eng. Tools and Methods

Version control systems are one of the main topics of

the Software Engineering Tools and Methods course,

together with software testing, build automation and

continuous integration and deployment. Teamwork

is an important soft skill that students should reach

along the course. With that aim, several software de-

velopment activities and a ﬁnal project are proposed

to students’ teams to learn and put into practice the

main contents of the course.

Students reach the course with some previous

knowledge of Git and GitHub basics, so at the be-

ginning, we focus on conﬂict resolution when merg-

ing changes from different users, presenting different

CSEDU 2022 - 14th International Conference on Computer Supported Education

292

Table 1: Involved courses.

Course Degree Semester Used approach(es)

Software Engineering Computer Science 3rd Project management, Autograding, Teamwork col-

lab, CI/CD

Software Engineering

Tools and Methods

Computer Science 6th Project management, Teamwork collab, CI/CD

Rapid Application

Development

Computer Science 8th Project management, Autograding, Teamwork col-

lab, CI/CD, Course material

Software Engineering

Processes II

Computer Science 8th Project management, Teamwork collab, Course

material

Programming Mechanical, Electric, Industrial Electron-

ics and Industrial Chemical Engineering

2nd Project management, Teamwork collab, Course

material

situations when conﬂicts can appear and how to re-

solve them. Different branches strategies that allow

developers to isolate their work and to minimize con-

ﬂicts when working in teams are reviewed and ap-

plied. GitHub is used for enabling team collaboration,

presenting two different approaches: 1) The central

repository model, when all teammates have ‘write’

permissions on the same remote GitHub repository,

and 2) The “fork and pull request” model, when only

one member has ’write’ access to the main repository,

called upstream, and the rest of team members have

only ‘read’ access in the upstream repository. We fo-

cus our interest on the last one since it is widely used

in the industry.

To promote commitment and individual effort in

collaborative activities, we review the GitHub feature

called Insights that provides a report of contributions

by each author along the time, showing summarized

information of what contributions were made by each

team member and when. Moreover, to ensure that the

author of a change is whom GitHub says, students

learn how to sign their commits.

Some alternatives to GitHub, such as GitLab and

Bitbucket, were evaluated several years ago. For

some years, GitLab was used in the course, which

provides a standalone version that can be downloaded

and installed into a machine managed by the stu-

dents’ team. Operating their own service support-

ing Git repositories was quite interesting for students,

as far as the feedback we received, even from lo-

cal companies that did not want to upload their pro-

prietary code into an online service such as GitHub,

which was historically known for hosting open source

software projects. However, this activity negatively

affected the course schedule since students used to

spend much more time on managing the server for

installing GitLab, setting up GitLab itself, creating

users and managing permissions, and they were not

able to start working on Git topics until everything

was properly set up. As an alternative of a Git-

Lab service operated by each student team was using

Gitlab.com, the online GitLab service; however, the

widespread use of GitHub and the additional educa-

tional resources that GitHub provides to higher insti-

tution students made us choose GitHub against others.

3.3 Rapid Application Development

In the course of Rapid Application Development, we

use the tools provided by GitHub to monitor and eval-

uate students. The fundamentals of this course, as the

name suggests, lies in the students being able to de-

velop applications in an efﬁcient and fast way through

the use of a series of frameworks that in turn imple-

ment development patterns widely used in the world

of programming.

To do this, we divide the course into three different

milestones:

• Backend. It includes all artifacts necessary for

the deployment of a backend, e.g., establishing

databases, message queues, APIs or whatever

middleware required.

• Frontend. It includes the software artifacts related

to a front web application that allows a user to

access and interact directly with the data provided

by the backend.

• Deployment. Artifacts developed in the two previ-

ous points, generating an infrastructure based on

containers for the different applications.

In order for students to meet the established ob-

jectives in the three milestones, apart from teaching

the theoretical concepts related to them, we propose

to the student the creation of two applications that, in

turn, will be used to evaluate them. The ﬁrst one is

developed individually by the student. The student

establishes the theme and technologies, this way, the

student becomes much more involved in the learning

process. We only demand from the student that the

application meets the three milestones. On the other

hand, the second application is a project that will be

made collaboratively. The teacher deﬁnes the theme

and technologies and coincides with the ones learned

in the course.

In the case of the individual application, the stu-

dent creates a private repository required to comply

Applying GitHub Services to Support Teaching-learning Strategies in Computer Science Courses

293

with a mainline branching strategy (Fowler, 2020).

In this strategy, the student have to generate a new

branch for each feature to implement and possi-

ble bugs detected in their application. The teacher,

throughout the course, is carrying out a detailed

follow-up of each private repository, in which he/she

controls if the student is fulﬁlling the milestones. In

turn, if any error is detected in the development of the

individual project, the teacher can create issues that

the student must resolve for the positive evaluation.

The modus operandi of the development of the

collective application is a little different. As we will

see below, we introduce the student in a more real

situation about the development of a project in a com-

pany. The teacher generates a team in the course or-

ganization. Next, a public repository is generated that

has an associated project to which the previously es-

tablished team is assigned. The milestones are estab-

lished in that repository, backend, frontend, and de-

ployment. In the associated project, we generate a

Kanban board to track students’ tasks. In this board,

the teacher generates ﬁve columns in which we es-

tablish a Scrum (Subra and Vannieuwenhuyse, 2018)

Board, agile development methodology that the sub-

ject follows for the project.

We have a series of fully automated columns in

which both students and teachers can follow the tasks

that are being developed at any given time. These

columns are as follows:

• Backlog: This column establishes all the issues

that both students and teachers generate in the

project development.

• Sprint Backlog: This column has all the issues be-

longing to the milestone that we are developing.

In the development of the collective project, we

established three different sprints of one month

each that coincides with the three milestones.

• In Progress: The moment an issue is assigned to a

student, it goes to this column.

• Under Review: When the student makes a Pull

Request indicating the issue number that he or she

has solved, the task goes to this column, being the

moment in which the teacher decides if this task

has a positive evaluation (accepts Pull Request) or

negative (rejects the Pull Request).

• Done: Once the Pull Request is accepted, the is-

sue is considered completed.

For the student evaluation, the teacher assigns a score

(in the range 0 to 5) to each issue generated in the

collective project. that indicates the issue difﬁculty.

Besides, each project issue is associated with one of

the course milestones. Furthermore, the student has

the power to assign him/herself an issue whenever

he/she wants, but only one at a time. In turn, it is

required that the student meets a minimum score in

each milestone so that part of the subject is consid-

ered passed. For the resolution of each issue, stu-

dents must ﬁrst fork of the course public repository,

in which they must work resolving the relevant is-

sue. Then, once they consider that they have solved

the particular issue, the student makes a Pull Request,

with the issue number they have resolved must ap-

pear, that the teacher will validate. Throughout the

course, the teacher launches the evaluation program

presented in Section 2 to check the student’ score in

each milestone. Score that will be taken into account

when evaluating them, and that we can check man-

ually in the project Kanban in the tasks that are ar-

ranged in the Done column. As you can see, the ob-

jective we have when studying this course is not only

that the student learns the concepts that are seen in it,

but that they acquire the necessary competence to be

able to work on a collaborative project.

3.4 Software Engineering Processes 2

The topics covered by this course are vast and di-

verse, but they are arranged in two well differenti-

ated aspects. First, fundamental issues for the exer-

cise of software engineers’ profession that include in-

ternational and national standards or the profession’s

ethics. Besides, it covers the measurements and met-

rics techniques that allow quality control, and the

study of how the software product development pro-

cesses have been applied, including all the analytic

processes of those metrics and the refactoring actions

selection.

Because this course is planned in the last semester

and coincidental with Rapid Application Develop-

ment, students are used to managing and develop-

ing software supported by the GitHub platform. We

outline the use of GitHub with a multi-project point

of view, which means that a student has to develop

projects in different domains (not always software re-

lated) belonging to various aleatory built teams. On

the one hand, students are forced to self-organize the

teams they belong to, and each team has the power

to decide how they will work. On the other hand,

each student individually suffers the pressure of the

deadlines of the issues assigned to them by their class-

mates.

Project boards are the most used GitHub feature in

this course because the only rule we set is that all the

tasks performed in the project have to be recorded,

assigned, monitored and commented using notes in

a Kanban board. This rule allows teachers to con-

CSEDU 2022 - 14th International Conference on Computer Supported Education

294

trol and evaluate students’ work. Furthermore, teach-

ers can sometimes deﬁne ad-hoc tasks assigned to the

team or speciﬁc students given feedback or improve-

ments/warnings to the built solutions.

In addition to multi projects coordination, another

point that students have to deal with is the connec-

tion and management of additional applications such

as Overleaf

, Codacy

, or SonarCloud

. The ﬁrst one

is used to develop a report about how to instantiate the

set of standard terminology and guidelines for project

management, Project Management Body of Knowl-

edge, to a project for elaborating their ﬁnal undergrad-

uate dissertation. In this assignment, the use of latex

as an external tool supported by a GitHub repository

and the project management for a not software project

are combined.

The Codacy application is used to automate code

reviews (bugs and vulnerabilities) on the commits and

pull requests of an easy software project. Each team

(two students) decides the programming language and

who is responsible for code and for review. The stu-

dent that reviews for a team is the coder in another

team. The followed rule is using GitHub issues and

tasks to communicate each other. Finally, Sonar-

Cloud, which has similar features to Codacy, is used

in a given software application, and a student has to

apply refactor actions (Fowler, 2018) that have to be

justiﬁed using issues and commit comments.

In all the assignments/projects, the GitHub repos-

itories are the submissions content to be evaluated by

the teachers, while commits and issued tracks are also

evaluation instruments.

3.5 Programming

Programming is an introductory course of the ﬁrst

year in the Mechanical Engineering, Electric Engi-

neering, Industrial Electronics Engineering and In-

dustrial Chemical Engineering degrees at the UAL.

Because current teaching methodologies focus on the

student’s work, the course is based on problem-based

learning and collaborative team-working (Garc

ıa-

azaro et al., 2015; Sol. et al., 2021).

This course is included in the competencies ”Soft-

ware Development Fundamentals” area of the Com-

puting Curricula, which recommends the ﬂuency in

at least a programming language, accomplished with

essential programming skills and programming con-

cepts, such as basic computation, simple and ﬁle I/O,

standard conditional and iterative structures, the deﬁ-

nition of functions, and parameter passing.

Overleaf – www.overleaf.com

Codacy – www.codacy.com/

SonarCloud – sonarcloud.io/

The lectures and laboratory lessons are based on

problems that require programming skills. The prob-

lems are scheduled in 13 cooperative working tasks

(CWT) and 15 autonomous tasks (AT). Each CWT is

described in a written instruction document that in-

cludes 3 or 6 problems that have to be collectively

solved by a team of 3 or 4 aleatory selected students.

Because the plan is common to all the students, it

is not pure problem-based learning. Nevertheless,

team members may decide the particular techniques

or C coding strategy. The AT assignments are no-

classroom activities. Instead, each one collects the ex-

ercises or problems to be done/coded autonomously.

Until last year, students used some Integrated De-

velopment Environment (IDE) in C/C++ program-

ming language that they can install in their personal

computers, and the solutions were reviewed manually

by the teachers. However, for the academic course

2022, a new workﬂow has been deﬁned based on the

GitHub services (

Aguila et al., 2022). Most of the

contents are going to be released on a GitHub organi-

zation. A repository containing a set of problems in

the ﬁeld of Industrial Engineering has been released

on the GitHub page and can be used as learning ob-

jects (

Aguila et al., 2021). The CWT and AT in-

structions have been included as readable ﬁles in two

repositories. These contents are written in Markdown,

a markup language that facilitates the production of

texts for the web. Because it is destination indepen-

dent, these texts can be reused to create other learning

materials, such as teachers’ or students’ notes.

Another GitHub feature that is going to be ap-

plied is the version control to help and promote co-

operative team working (

Aguila et al., 2022). The

students are arranged in several teams sharing a com-

mon repository that the different teammates will com-

plete. Each student has to manage two repositories,

the ﬁrst one to collect AT solutions and a second one

to solve group assignments, CWT. These tasks are

structured in smaller problems where positive inter-

dependence is needed. Finally, the exercises are dis-

tributed among the members, and the solutions have

to be agreed upon and merged. The use of teamwork

and commits history will help teachers analyze how

effective their learning strategy is.

4 CONCLUSIONS

This article describes the set of solutions and strate-

gies that have been applied to ﬁve courses related to

the Computer Science domain as part of the research

work of two innovation teaching projects of the Uni-

versity of Almer

ıa (UAL).

Applying GitHub Services to Support Teaching-learning Strategies in Computer Science Courses

295

These strategies apply GitHub services to sup-

port and improve the teaching-learning processes, due

to the provided features and the widespread use of

this technology. In this article, we deﬁne the differ-

ent strategies and approaches supported by the use

of GitHub, like project management, collaborative

working, the use of CI/CD processes for automatic

validation of exercises, or simply by sharing material

thanks to the capabilities provided by the platform.

Furthermore, we provide a tool for creating and man-

aging GitHub repositories, to avoid repetitive tasks

such as creating an issue in multiple repositories.

The results obtained by applying the strategies in

the different courses are promising. They have made

it possible to unify teaching-learning strategies within

the Degree of Computer Science of the UAL.

There are still open research lines for building spe-

ciﬁc protocols and methodologies for each course,

and for extrapolate the established strategies to other

courses with similar characteristics.

ACKNOWLEDGEMENTS

This work has been funded by 21-22-2-13C and 21-

22-1-11C projects, call for the Creation of Teaching

Groups for Innovation and Good Practices and for the

Creation of Teaching Materials of the UAL. Manel

Mena has been funded by a grant (ref. FPU17/02010)

from the Spanish Government.

REFERENCES

Aguila, I., Ca

nadas, J., and Garc

ıa, J. R. (2022). Github

repository with learning objects for industrial engi-

neering degrees in programming. In Proc. IEEE

EDUCON. Global Engineering Education.

Aguila, I., Garc

ıa, J. R., Guirado, R., and Miranda, C. M.

(2021). Github repository with learning objects for in-

dustrial engineering degrees in programming. In Proc.

VII CINAIC’2021, pages 86–90.

Ammann, P. and Offutt, J. (2016). Introduction to software

testing. Cambridge University Press.

Angulo, M. A. and Aktunc, O. (2019). Using github as a

teaching tool for programming courses. In 2018 Gulf

Southwest Section Conference.

CC2020 Task Force (2020). Computing curricula 2020:

Paradigms for global computing education.

Criado, J., Ca

nadas, J., Iribarne, L., and Miranda, C. (2020).

Automatic assessment of uml models for improving

the learning of software engineering students. In Proc.

ICERI2020, pages 1855–1858.

Feliciano, J., Storey, M.-A., and Zagalsky, A. (2016). Stu-

dent experiences using github in software engineering

courses: a case study. In Proc. IEEE/ACM 38th ICSE-

C, pages 422–431. IEEE.

Fiksel, J., Jager, L. R., Hardin, J. S., and Taub, M. A.

(2019). Using github classroom to teach statistics.

Journal of Statistics Education, 27(2):110–119.

Fowler, M. (2018). Refactoring: improving the design of

existing code. Addison-Wesley Professional.

Fowler, M. (2020). Patterns for managing source code

branches. https://cutt.ly/jIO6X55. [Online; accessed

19-January-2022].

Garc

ıa-L

azaro, J., Moreno-Ruiz, J., Aguilla Cano, I., and

Guirado Clavijo, R. (2015). Teaching computer pro-

gramming in the degrees of industrial engineering

with collaborative and problem-based learning. In

Proc. EDULEARN15, pages 7623–7633.

Glazunova, O., Parhomenko, O., Korolchuk, V., and

Voloshyna, T. (2021). The effectiveness of github

cloud services for implementing a programming train-

ing project: students’ point of view. J. Phys.: Conf.

Ser., 1840:012030.

Gronback, R. C. (2009). Eclipse modeling project: a

domain-speciﬁc language (DSL) toolkit. Pearson Ed-

ucation.

Gutica, M. (2018). Improving students’ engagement with

large-team software development projects. In Proc.

23rd ACM ITiCSE, pages 356–357.

Malakar, S. (2021). AGILE in Practice: Practical Use-

cases on Project Management Methods including Ag-

ile, Kanban and Scrum. BPB Publications.

Malikowski, S. R., Thompson, M. E., and Theis, J. G.

(2007). A model for research into course management

systems: Bridging technology and learning theory. J.

Educ. Comput. Res., 36(2):149–173.

Nelson, M. A. and Ponciano, L. (2021). Experiences and in-

sights from using github classroom to support project-

based courses. arXiv preprint arXiv:2103.07242.

Rahman, A., Partho, A., Morrison, P., and Williams, L.

(2018). What questions do programmers ask about

conﬁguration as code? In Proc. 4th RCoSE, pages

16–22.

Seidl, M., Scholz, M., Huemer, C., and Kappel, G. (2015).

UML@ classroom: An introduction to object-oriented

modeling. Springer.

Smart, J. F. (2011). Jenkins: The Deﬁnitive Guide. O’Reilly

Media, Inc.

Sol., R., Santos., E., Reis., M., and Pereira., L. (2021).

Computer supported collaborative learning for pro-

gramming: A systematic review. In Proc. 13th

CSEDU, pages 184–191.

Subra, J.-P. and Vannieuwenhuyse, A. (2018). Scrum: un

etodo

agil para sus proyectos. Ediciones ENI.

Tushev, M., Williams, G., and Mahmoud, A. (2020). Us-

ing github in large software engineering classes. an

exploratory case study. Computer Science Education,

30(2):155–186.

Zagalsky, A., Feliciano, J., Storey, M.-A., Zhao, Y., and

Wang, W. (2015). The emergence of github as a col-

laborative platform for education. In Proc. 18th ACM

CSCW, pages 1906–1917.

CSEDU 2022 - 14th International Conference on Computer Supported Education

296