Techela - Technology Enhanced Learning and Assessment

Introduction

Techela is a framework for teaching courses. It provides a way to distribute, collect, grade, and return digital assignments.

Initial server setup

The initial setup of a techela course on the techela server is described here. For this example, we create a course with a label of su16-org. You should create a course “recipe” and put it in the courses folder of techela. Here is an example of the recipe. This registers the course with techela.

(su16-org
 :title "Short course in org-mode"
 :course-number "N/A"
 :year 2016
 :semester "Summer"
 :instructor "John Kitchin"
 :instructor-email "jkitchin@andrew.cmu.edu"
 :course-repo "https://github.com/KitchinHUB/kitchingroup"
 :techela-server "su16-org@techela.cheme.cmu.edu")

Create a new user on the server

The server is run on an ordinary Linux server under a dedicated user. The username should match the username in the :techela-server property of the course recipe. Here are two commands to create a new user and password for the user. If you run your own server you will do this, otherwise you will need the techela server administrator to make your account.

ssh root@techela.cheme.cmu.edu useradd  su16-org

In this next command, you should change passwd to whatever password you want to use.

ssh root@techela.cheme.cmu.edu passwd su16-org

Setup local ssh key to techela server

First, we make sure we have a .ssh directory and authorized_keys file with the right permissions on the remote server.

ssh su16-org@techela.cheme.cmu.edu "mkdir -p .ssh && chmod 700 .ssh && touch .ssh/authorized_keys && chmod 600 .ssh/authorized_keys"

Next, you should setup a local ssh-key so you can connect to this account without a password.

If you don’t have a ~/.ssh/id_rsa key setup run this to setup an ssh key with no password:

[ ! -e ~/.ssh/id_rsa ] ssh-keygen -t rsa -f ~/.ssh/id_rsa -N ""

Now copy it to the techela account like this.

cat ~/.ssh/id_rsa.pub | ssh su16-org@techela.cheme.cmu.edu "cat >> .ssh/authorized_keys"

Now you should be able to run commands like this and not be prompted for a password.

ssh su16-org@techela.cheme.cmu.edu ls

Setup the remote and local directories

Run this command one time to setup the remote and local directories for the course elisp:tq-setup-course

Course setup in gitolite-admin

This section describes the “private” course setup, i.e. the part students do not need to see.

keydir

gitolite requirement. Contains userid.pub files.

conf

gitolite requirement. Contains gitolite.conf, which sets up repos.

conf/student-work

We can actually create repo.conf files in this directory, and they are included in the gitolite.conf automatically. We only make one repo.conf per repository.

conf/students.conf

This file defines the @students group. It is usually generated automatically from the roster. Initially this file should have these contents:

@students =

gradebook

This directory contains a grading file for each assignment. The files contain links to each file, and a summary of the grades.

../course

This is the student facing part of the course. The syllabus should go in here, and any course notes/materials. This is a separate git repository that is usually publicly visible.

../student-work

Student repos will be cloned into this directory. This is where their work will be pulled after it is collected.

../class-work

Class repos will be cloned here. This is where you pull class repos for analysis.

../assignments

Assignments are referred to by label. There should be a directory with the name “label” for each assignment. The contents of this directory will be copied to student repos, so do not put solutions here!

Each assignment should also contain #+POINTS, #+CATEGORY and #+DUEDATE information, which is added to the syllabus when you use elisp:tq-assign-assignment

You create a new assignment repo simply by:

git clone su16-org@techela.cheme.cmu.edu:assignments/label

This automatically creates the remote repo and local directory. Then, you add your content to it and push it back. You have to separately assign it.

Running your course

Create assignments

Assignments exist in a file called assignments.org in the gitolite-admin directory. Problems are in headlines with a CUSTOM_ID, and solutions should be in a subheading tagges with :solution:.

Assign assignments

Assignment is a multistep process. First, you create the assignment, commit and push it to the server. This is done in one of two ways:

1. In the assignments directory, run

git clone su16-org@techela.cheme.cmu.edu:assignments/label

Create the content in the label directory, commit it and push it.

1. Run a command to create the repo from the assignments.org file.

Then, you need to create repos for each student. This is done with elisp:tq-create-assignment-repos. That will create repos for each student that are empty, and with no access for the students. Next, you assign an assignment with elisp:tq-assign-assignment. This will give students access to the assignment, and give them RW access to their repo to turn it in. Finally, an entry in the syllabus is added so the students will know when it is due.

Collect assignments

There are a few steps in collecting an assignment too. The fastest step is to run elisp:tq-collect, which simply changes the student repos to read-only. To view the work, you must run elisp:tq-pull-repos, which will pull all the student work to your local repo.

Grade assignments

You run elisp:tq-grade, which will collect the assignment, pull them, and generate a grading document with links to each assignment. You will click on each link to grade each assignment. In each assignment, provide feedback and finally elisp:gb-grade. You will be prompted for a letter grade for each category of the rubric. This function will compute the weighted average grade.

Returning assignments

Run elisp:tq-return to commit all changes to each student repo and push them back to the server.

FAQ

Can I do teams?

Yes. You can define teams in gitolite-admin/gitolite.conf like this:

@team-1 = userid1 userid2 userid3

Then, you can create repos with team access like this:

repo team-project-1
    RW = @team-1

Can students turn in a Word document? or a PPT presentation? Or a …?

Any kind of file can be turned in. Simply put a copy of the file into the assignment directory and run the tq-turn-it-in command. All files in the directory will be turned in.

Do I have to use Emacs or org-mode?

Not really, but sort of. Techela is a git based framework for distributing and collecting course materials. You can use git any way you want. However, you will have to roll your own solutions to use another method, e.g. Python or shell script. You will also not be able to get the integrated syllabus/grading tools that only exist in org-mode + Emacs.

Create assignment repos

As an instructor you create an assignment repo like this:

git clone org-course@techela.cheme.cmu.edu:a/label

cd label
# Add files
git add files
git commit files -m "some message"
git push -u origin master

When it is time to assign the assignment to students, you need to create private repos for each student. While these can be any path you want, I you make them like this. For each student, create a file in the gitolite-admin/conf/student-work/label/userid-label.conf with the following contents.

repo student-work/label/userid-label
    RW = userid

When you have created all of them, do this in the gitolite-admin directory:

git add conf/student-work
git commit -m "add new assignment repos"
git push

This creates bare repos on the server that students can access.

Then, you run this command to give students read access to the assignment repo.

ssh org-course@techela.cheme.cmu.edu perms + READERS @students

Students will run this command to clone the repo to their local machine. They only have read permission on this repo so they need to change the remote they will push to.

git clone org-course@techela.cheme.cmu.edu:a/label
cd label
git remote rename origin src
git remote add origin org-course@techela.cheme.cmu.edu:student-work/label/userid-label

They will do their work in the label directory, and when they are done perform the following commands.

git add *
git commit -am "Turning work in"
git push -u origin master

Collecting the assignments

You need to change the conf file for each assignment repo to have the correct permissions, in this case, read-only for the students like this.

repo student-work/label/userid-label
    R = userid

When you have modified all of them, do this in the gitolite-admin directory:

git add conf/student-work
git commit -m "add new assignment repos"
git push

Now, you need to clone/pull each repo to your local machine. The first time you do this, you will have to clone them, e.g.

cd student-work/label/userid-label
git clone org-course@techela.cheme.cmu.edu:student-work/label/userid-label
cd user-label
git tag -a turned-in -m "Work turned in by student" 

You will do your grading, and then run this command to “return” the work.

git tag -a graded -m "graded" 
git add *
git commit -am "Finished grading"
git push --tags -u origin master

Finally, students need to pull their repo to see the grade and feedback.