`git4ol` guide

The document is written as a guide that takes the reader through the various actions taken by our actors from the beginning when an author creates his initial work to when a student accepts a certificate for an assignment.

We've chosen this format for two reasons:

To lower the technical barrier of entry to anyone who understand basic git commands
To provide a step-by-step guide that cover all of the core aspects of git4ol

note

In this document you'll be able to see what the active role is in two ways:

Actor changes are noteted like so: actor: xxx

When a shell command is issued check the format of the prompt:
actor@shell:cwd$

Basics

Before continuing we should go over some basic git commands. First let's decide if we're starting from an empty repository or a clone.

note

We've used the repository url https://github.com/open-learning/git4ol.git throughout this document, substitute with your own

Initialize

If you are starting from an empty repository you'll first have to initialize the new repository using git init:

user@shell:~/$ git init git4ol
Initialized empty Git repository in /home/user/git4ol/.git/
user@shell:~/$ cd git4ol
user@shell:~/git4ol$

Once we have our initialized repository we should git remote add our origin repository url:

user@shell:~/git4ol$ git remote add origin https://github.com/open-learning/git4ol.git

Clone

If we're starting from an existing repository we need clone it using git clone:

user@shell:~/$ git clone https://github.com/open-learning/git4ol.git
Cloning into 'git4ol'...
remote: Counting objects: 132, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 132 (delta 0), reused 0 (delta 0), pack-reused 129
Receiving objects: 100% (132/132), 14.31 KiB | 0 bytes/s, done.
Resolving deltas: 100% (48/48), done.
Checking connectivity... done
user@shell:~/$ cd git4ol/
user@shell:~/git4ol$

References

A lot of things in git are already managed using git references (refs) including (but not limited to) branches, tags and remotes.

To list existing references use git for-each-ref:

user@shell:~/git4ol$ git for-each-ref
2042bd20e49548e677a3212a4ebe428168739643 commit	refs/heads/master
2042bd20e49548e677a3212a4ebe428168739643 commit	refs/remotes/origin/HEAD
2042bd20e49548e677a3212a4ebe428168739643 commit	refs/remotes/origin/master

You can limit the listing by providing a pattern:

user@shell:~/git4ol$ git for-each-ref refs/heads/*
2042bd20e49548e677a3212a4ebe428168739643 commit	refs/heads/master

You can add, modify and delete git refs using git update-ref. To add a ref called test pointing to the current HEAD just do this:

user@shell:~/git4ol$ git update-ref refs/test HEAD

By default git only fetches refs/heads/* and refs/tags/* refs so if we use other refs we have to git fetch them ourselves:

user@shell:~/git4ol$ git fetch origin refs/markdown@0.0.0/*:refs/markdown@0.0.0/*

To see what refs exist for a range of commits we can use git log:

note

In this example we've assumed you've already git fetched refs/markdown@0.0.0/*

user@shell:~/git4ol$ git log --oneline --reverse --decorate=full
1158e62 (refs/markdown@0.0.0/step/1) Our first markdown file
edef49d (refs/markdown@0.0.0/step/2) Paragraphs, Headers, Blockquotes
4241e04 (refs/markdown@0.0.0/step/3) Phrase Emphasis
c20460b (refs/markdown@0.0.0/step/4) Unordered  Lists
35c27fe (refs/markdown@0.0.0/step/5) Ordered  Lists
af66145 (refs/markdown@0.0.0/step/6) Complex lists
2a263e9 (refs/markdown@0.0.0/step/7) Inline Links
fd92020 (refs/markdown@0.0.0/step/8) Inline Links with a Title
74d3f68 (refs/markdown@0.0.0/step/9) Reference Links
67c62fd (refs/markdown@0.0.0/step/10) Reference Links with options
29c53d7 (refs/markdown@0.0.0/step/11) Images
1f1e90d (refs/markdown@0.0.0/step/12) Inline Code
aa15a6f (refs/markdown@0.0.0/step/13) Block Code

To see the instructions for a ref we can use git log again:

user@shell:~/git4ol$ git log -1 --format=%B markdown@0.0.0/step/1
Our first markdown file

type: ide
files:
  - README.md
---

[Markdown](http://daringfireball.net/projects/markdown/) is a text-to-HTML conversion tool for web writers. Markdown allows you to write using an easy-to-read, easy-to-write plain text format

Let's start by adding a `README.md` file with some mock content.

Authoring

actor: author

This part of the guide assumes the actor is an author

Creating a lesson is as basic as adding commits to a branch. It's mostly when we need to modify one that it can get a little bit more complicated.

Creating a lesson

To create the initial version of a lesson we need to first create a new directory and initialize an empty repository:

author@shell:~/$ mkdir git4ol
author@shell:~/$ cd git4ol
author@shell:~/git4ol$ git init
Initialized empty Git repository in /home/author/git4ol/.git/

Second step is to create an orphaned WIP branch:

note

In this example markdown is the name of our WIP branch

author@shell:~/git4ol$ git checkout --orphan markdown

Incrementally add commits to this branch and when all of the steps are added we need to add step refs. Let's first list the (imaginary) commits we just added using git log:

author@shell:~/git4ol$ git log --oneline --reverse
1158e62 Our first markdown file
edef49d Paragraphs, Headers, Blockquotes
4241e04 Phrase Emphasis
c20460b Unordered  Lists
35c27fe Ordered  Lists
af66145 Complex lists
2a263e9 Inline Links
fd92020 Inline Links with a Title
74d3f68 Reference Links
67c62fd Reference Links with options
29c53d7 Images
1f1e90d Inline Code
aa15a6f Block Code

To add corresponding step refs we use git update-ref:

note

We use 0.0.0 as our initial version. After this we follow semver 2.0.0:

Given a version number MAJOR.MINOR.PATCH, increment the:

MAJOR version when you make incompatible API changes,

MINOR version when you add functionality in a backwards-compatible manner, and

PATCH version when you make backwards-compatible bug fixes.

author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/1 1158e62
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/2 edef49d
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/3 4241e04
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/4 c20460b
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/5 35c27fe
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/6 af66145
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/7 2a263e9
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/8 fd92020
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/9 74d3f68
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/10 67c62fd
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/11 29c53d7
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/12 1f1e90d
author@shell:~/git4ol$ git update-ref refs/markdown@0.0.0/step/13 aa15a6f

The last thing to do is to make all of this available to the world using git push:

author@shell:~/git4ol$ git push origin refs/markdown@0.0.0:refs/markdown@0.0.0/*

Updating a lesson

When updating a lesson we start by checking out the ref of the last step we'll modify of the lesson we're about to update into a detached HEAD:

note

In this example we'll modify lesson steps all the way up to step/13

author@shell:~/git4ol$ git checkout markdown@0.0.0/step/13
Note: checking out 'markdown@0.0.0/step/13'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD is now at aa15a6f... Block Code

In the following commits we're going to fix some formatting error(s) in markdown@0.0.0/step/3 and in the steps onwards, so let's start an interactive git rebase from the preceding step markdown@0.0.0/step/3~1:

author@shell:~/git4ol$ git rebase --interactive markdown@0.0.0/step/3~1

This let's us interactively choose what commits we need to edit. Change the word pick to edit on the commits that need editing and save:

edit 4241e04 Phrase Emphasis
edit c20460b Unordered  Lists
edit 35c27fe Ordered  Lists
edit af66145 Complex lists
edit 2a263e9 Inline Links
edit fd92020 Inline Links with a Title
edit 74d3f68 Reference Links
edit 67c62fd Reference Links with options
edit 29c53d7 Images
edit 1f1e90d Inline Code
edit aa15a6f Block Code

# Rebase edef49d..aa15a6f onto edef49d
#
# Commands:
#  p, pick = use commit
#  r, reword = use commit, but edit the commit message
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#  f, fixup = like "squash", but discard this commit's log message
#  x, exec = run command (the rest of the line) using shell
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out

This will drop us to back to the shell:

author@shell:~/git4ol$ git rebase --interactive markdown@0.0.0/step/3~1
Stopped at 4241e04... Phrase Emphasis
You can amend the commit now, with

	git commit --amend

Once you are satisfied with your changes, run

	git rebase --continue

We're going to update README.md and fix the indentation error in the end of the file, save it, git add the changes and then git rebase --continue:

author@shell:~/git4ol$ git add README.md
author@shell:~/git4ol$ git rebase --continue
[detached HEAD e5851e7] Phrase Emphasis
 1 file changed, 6 insertions(+)
error: could not apply c20460b... Unordered  Lists

When you have resolved this problem, run "git rebase --continue".
If you prefer to skip this patch, run "git rebase --skip" instead.
To check out the original branch and stop rebasing, run "git rebase --abort".
Could not apply c20460b... Unordered  Lists

Since the changes we've done to README.md collide with later changes we'll have to solve the conflict, apply the needed changes (indentation), git add the change then continue the rebase using git rebase --continue:

author@shell:~/git4ol$ git add README.md 
author@shell:~/git4ol$ git rebase --continue
[detached HEAD 867e400] Unordered  Lists
 1 file changed, 12 insertions(+)
error: could not apply 35c27fe... Ordered  Lists

When you have resolved this problem, run "git rebase --continue".
If you prefer to skip this patch, run "git rebase --skip" instead.
To check out the original branch and stop rebasing, run "git rebase --abort".
Could not apply 35c27fe... Ordered  Lists

Keep resolving conflicts and applying changes until the end of the rebase is reached.

author@shell:~/git4ol$ git rebase --continue
[detached HEAD a20f371] Block Code
 1 file changed, 7 insertions(+)
Successfully rebased and updated detached HEAD.

Once the rebase is completed your new lesson is ready to be published! From here it's the same as when authoring a new lesson:

note

Note that the new version is 0.0.1 since we are publishing an fix version of 0.0.0

git update-ref refs/markdown@0.0.1/step/{n} {commit}
git push origin refs/markdown@0.0.1/*:refs/markdown@0.0.1/*

Challenges

Challenges are typically (but not always) based on a lesson step. When adding challenges we start by checking out the challenge ref into a detached HEAD:

note

In this example we're basing our challenge on the ref markdown@0.0.1/step/2 but anything git commit-ish is valid

author@shell:~/git4ol$ git checkout markdown@0.0.1/step/2
Note: checking out 'markdown@0.0.1/step/2'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD is now at 870c12a... Paragraphs, Headers, Blockquotes

Let's add an empty file for our student to provide feedback in and then git add it:

author@shell:~/git4ol$ touch assignment.md
author@shell:~/git4ol$ git add assignment.md

Now we want to commit this using git commit:

author@shell:~/git4ol$ git commit --message="Your first assignment

type: ide
files:
  - README.md
---

Let's see what we've learned so far. We've created a file called \`assignment.md\` that you should use to submit your answer.

Add three headings from level one to three, pick whatever heading contents as you want."
[detached HEAD 32f165d] Your first assignment
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 assignment.md

Now that we've added this challenge we need to add a ref to it using git update-ref:

note

In this example the name of the challenge is first-assignment

author@shell:~/git4ol$ git update-ref refs/markdown@0.0.1/challenge/first-assignment HEAD

The last thing to do is to make all of this available to the world using git push:

author@shell:~/git4ol$ git push origin refs/markdown@0.0.1/*:refs/markdown@0.0.1/*
Counting objects: 4, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 413 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/open-learning/git4ol.git
 * [new branch]      refs/markdown@0.0.1/challenge/first-assignment -> refs/markdown@0.0.1/challenge/first-assignment

Studying

actor: student

This part of the guide assumes the actor is a student

Depending on the lesson assignments studying can be done either entirely by the student alone (in the case of self assessed or machine assessed assignments) or together with someone else as in the case of teacher or peer assessed assignments.

Stepping

We navigate a lesson steps using git checkout:

student@shell:~/git4ol$ git checkout markdown@0.0.1/step/1
Note: checking out 'markdown@0.0.1/step/1'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD is now at db6f200... Our first markdown file

To display the instructions we use git log:

student@shell:~/git4ol$ git log -1 --format=%B
Our first markdown file

type: ide
files:
  - README.md
---

[Markdown](http://daringfireball.net/projects/markdown/) is a text-to-HTML conversion tool for web writers. Markdown allows you to write using an easy-to-read, easy-to-write plain text

Let's start by adding a `README.md` file with some mock content.

Assignments

Assignments are just challenges that contain assignment materials. In this example we'll start an assignment by checking out the challenge ref to a detached HEAD:

student@shell:~/git4ol$ git checkout markdown@0.0.1/challenge/first-assignment
Note: checking out 'markdown@0.0.1/challenge/first-assignment'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD is now at 32f165d... Your first assignment

Let's look at the instructions for this assignment using git log:

student@shell:~/git4ol$ git log -1 --format=%B
Your first assignment

type: ide
files:
  - README.md
---

Let's see what we've learned so far. We've created a file called `assignment.md` that you should use to submit your answer.

Add three headings from level one to three, pick whatever heading contents as you want.

Let's follow the instructions and add three lines of heading to assignment.md:

student@shell:~/git4ol$ echo "#1
##2
###3" > assignment.md

Assessment

Assignments can either be locally or remotely assessed.

In the case of local assessment the tests needed to validate an assignment (like unit tests) should be provided with the assignment. Local assessment can then be done by simply running the tests in a test runner.

In the case of remote assessed assignments we think of the assignment in two parts:

The "challenge" part of an assignment is a git commit containing description and assets
The "response" part of an assignment is a pull request describing the commits to be reviewed

Preparation

Before we submit this assignment we have to create a more permanent assignment branch using git checkout:

note

Here first-attempt is the name of our attempt (since it's our first attempt)

student@shell:~/git4ol$ git checkout -b markdown@0.0.1/challenge/first-assignment#first-attempt
M	assignment.md
Switched to a new branch 'markdown@0.0.1/challenge/first-assignment#first-attempt'

We want the last changes we made to assignment.md to be part of our submission so let's add it to our commit using git add:

student@shell:~/git4ol$ git add assignment.md

Now all we have to do is to commit our changes using git commit:

student@shell:~/git4ol$ git commit --message="Update assignment.md"
[markdown@0.0.1/challenge/first-assignment1#first-attempt cc92916] Update assignment.md
 1 file changed, 3 insertions(+)

The assignment is now ready for "review" but before that can start we have to make our changes available to the world by pushing our assignment branch using git push:

student@shell:~/git4ol$ git push origin refs/heads/markdown@0.0.1/challenge/first-assignment#first-attempt
Counting objects: 5, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 294 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/open-learning/git4ol.git
 * [new branch]      markdown@0.0.1/challenge/first-assignment#first-attempt -> markdown@0.0.1/challenge/first-assignment#first-attempt

Submission

Assignment submissions are handled using git pull-requests from the student's assignment branch to the teacher's review branch.

How the pull-request workflow looks will differ from teacher to teacher. In this example we're simply going to go bare-bones-old-school and use git request-pull to generate a pull-request text that can be used as a starting point for whatever flavour of workflow.

student@shell:~/git4ol$ git request-pull markdown@0.0.1/challenge/first-assignment https://github.com/open-learning/git4ol.git
The following changes since commit 32f165df11dee9305c75d82f11ddda71940df154:

  Your first assignment (2015-05-07 01:00:01 +0800)

are available in the git repository at:

  https://github.com/open-learning/git4ol.git markdown@0.0.1/challenge/first-assignment#first-attempt

for you to fetch changes up to cc92916032dd43e9ab2831133a6c52de1e50bb13:

  Update assignment.md (2015-05-07 01:15:37 +0800)

----------------------------------------------------------------
student (1):
      Update assignment.md

 assignment.md | 3 +++
 1 file changed, 3 insertions(+)

Review

note

The whole review workflow is based on the git pull-request model but adjusted to of whatever flavour and toolset the teacher may favour and as such is not defined in this document.

There are a bunch of tools and workflows out there to choose from for doing reviews:

Plain old email is the most basic and only reqires access to a mail account (this is how git itself is maintained)
GitHub pull-requests are great for public submissions and reviews and is probably your best option to get started quickly
Gerrit is probably a bit more than you are looking for, but there's a lot of organizations (like google) that use it on an enterprise level

Each workflow has their own advantages and disadvantages but in the end of the day we end up with a branch in the students repository with a reviewed solution to an assignment.

Normally a reviewed pull-request results in the reviewer accepting the changes and merging them into the targeted branch, but in this case we're not looking to review and merge, but to review and certify.

Certification

A "certificate" is a json file containing a Mozilla open badge assertion with evidence pointing to the original "assignment" commit. Certificate submissions are handled using git pull-requests from the teachers's certification branch to the students's assignment branch.

For the purpose of this document we can generate our certificate using the Mozilla badge lab but in a production environment the acrediting organization should probably host an instance of the Mozilla badge kit and use that to issue certificates.

note

This document won't cover the details of creating assertions. Assume we've correctly generated our assertion and stored the JSON at ~/certificate.json by now and are ready to use it.

Before we can issue a certificate we have to have a local copy of the student's assignment branch. Assuming we already have a local clone of the git4ol repository we start by git remote add the student repository:

teacher@shell:~/git4ol$ git remote add student https://github.com/open-learning/git4ol.git

Once we have the remote, let's git fetch available branches from our student remote:

teacher@shell:~/git4ol$ git fetch student
remote: Counting objects: 17, done.
remote: Total 17 (delta 0), reused 0 (delta 0), pack-reused 17
Unpacking objects: 100% (17/17), done.
https://github.com/open-learning/git4ol
 * [new branch]      markdown@0.0.1/challenge/first-assignment#first-attempt -> student/markdown@0.0.1/challenge/first-assignment#first-attempt
 * [new branch]      master     -> student/master

Lastly let's git checkout the student assignment branch:

teacher@shell:~/git4ol$ git checkout student/markdown@0.0.1/challenge/first-assignment#first-attempt
Note: checking out 'student/markdown@0.0.1/challenge/first-assignment#first-attempt'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD is now at cc92916... Update assignment.md

Now that we have a working copy of the student assignment we want to copy the certificate file, git add it and lastly git commit it:

teacher@shell:~/git4ol$ cp ~/certificate.json certificate.json
teacher@shell:~/git4ol$ git add certificate.json
teacher@shell:~/git4ol$ git commit -m "Create certificate.json"
[detached HEAD 5adf1cb] Create certificate.json
 1 file changed, 4 insertions(+)
 create mode 100644 certificate.json

Before we submit this certificate we have to create a more permanent certification branch using git checkout:

note

Note that we've prefixed the branch name with student/ in order to group submissions from the same student together.

teacher@shell:~/git4ol$ git checkout -b student/markdown@0.0.1/challenge/first-assignment#first-attempt
Switched to a new branch 'student/markdown@0.0.1/challenge/first-assignment#first-attempt'

Now we need to make this available to the world using git push:

teacher@shell:~/git4ol$  git push origin refs/heads/student/markdown@0.0.1/challenge/first-assignment#first-attempt
Counting objects: 4, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 353 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/open-learning/git4ol.git
 * [new branch]      student/markdown@0.0.1/challenge/first-assignment#first-attempt -> student/markdown@0.0.1/challenge/first-assignment#first-attempt

And lastly we wan't to generate a pull-request to send our student using git request-pull:

teacher@shell:~/git4ol$ git request-pull remotes/student/markdown@0.0.1/challenge/first-assignment#first-attempt https://github.com/open-learning/git4ol.git
The following changes since commit cc92916032dd43e9ab2831133a6c52de1e50bb13:

  Update assignment.md (2015-05-07 01:15:37 +0800)

are available in the git repository at:

  https://github.com/open-learning/git4ol.git student/markdown@0.0.1/challenge/first-assignment#first-attempt

for you to fetch changes up to 5adf1cba10b9ade4666ae448f4f8040e0a6826b7:

  Create certificate.json (2015-05-07 01:33:56 +0800)

----------------------------------------------------------------
teacher (1):
      Create certificate.json

 certificate.json | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 certificate.json

Commencement

actor: student

This part of the guide assumes the actor is a student

Before we can accept a certificate we have to add a teacher remote. Assuming we already have a local clone of the git4ol repository we should git remote add the teacher repository:

student@shell:~/git4ol$ git remote add teacher https://github.com/open-learning/git4ol.git

Once we have the teacher remote added, let's git fetch available branches from it:

student@shell:~/git4ol$ git fetch teacher
remote: Counting objects: 17, done.
remote: Total 17 (delta 0), reused 0 (delta 0), pack-reused 17
Unpacking objects: 100% (17/17), done.
https://github.com/open-learning/git4ol
 * [new branch]      student/markdown@0.0.1/challenge/first-assignment#first-attempt -> teacher/student/markdown@0.0.1/challenge/first-assignment#first-attempt
 * [new branch]      master     -> teacher/master

Now we have to make sure we're on the correct assignment branch using git checkout:

student@shell:~/git4ol$ git checkout markdown@0.0.1/challenge/first-assignment#first-attempt
Switched to branch 'markdown@0.0.1/challenge/first-assignment#first-attempt'

Now all we have to do is to git merge from the teacher remote in order to "accept" our certificate:

student@shell:~/git4ol$ git merge --no-ff teacher/student/markdown@0.0.1/challenge/first-assignment#first-attempt
Merge made by the 'recursive' strategy.
 certificate.json | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 certificate.json

And finally let's make this available to the world using git push:

student@shell:~/git4ol$ git push origin refs/heads/markdown@0.0.1/challenge/first-assignment#first-attempt
Counting objects: 1, done.
Writing objects: 100% (1/1), 282 bytes | 0 bytes/s, done.
Total 1 (delta 0), reused 0 (delta 0)
To https://github.com/open-learning/git4ol.git
   cc92916..52f7dd1  markdown@0.0.1/challenge/first-assignment#first-attempt -> markdown@0.0.1/challenge/first-assignment#first-attempt

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

guide.md

guide.md

`git4ol` guide

Basics

Initialize

Clone

References

Authoring

Creating a lesson

Updating a lesson

Challenges

Studying

Stepping

Assignments

Assessment

Preparation

Submission

Advertisement

Review

Certification

Commencement

Files

guide.md

Latest commit

History

guide.md

File metadata and controls

git4ol guide

Basics

Initialize

Clone

References

Authoring

Creating a lesson

Updating a lesson

Challenges

Studying

Stepping

Assignments

Assessment

Preparation

Submission

Advertisement

Review

Certification

Commencement

`git4ol` guide