Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/jkitchin/techela-emacs

Technology enhanced learning and assessment
https://github.com/jkitchin/techela-emacs

Last synced: about 2 months ago
JSON representation

Technology enhanced learning and assessment

Awesome Lists containing this project

README 

        
#+TITLE: Techela - Technology Enhanced Learning and Assessment

#+AUTHOR: John Kitchin



* 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.



#+BEGIN_SRC emacs-lisp :tangle courses/su16-org

(su16-org

 :title "Short course in org-mode"

 :course-number "N/A"

 :year 2016

 :semester "Summer"

 :instructor "John Kitchin"

 :instructor-email "[email protected]"

 :course-repo "https://github.com/KitchinHUB/kitchingroup"

 :techela-server "[email protected]")

#+END_SRC



** 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.



#+BEGIN_SRC sh

ssh [email protected] useradd  su16-org

#+END_SRC



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

#+BEGIN_SRC sh

ssh [email protected] passwd su16-org

#+END_SRC



** 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.



#+BEGIN_SRC sh

ssh [email protected] "mkdir -p .ssh && chmod 700 .ssh && touch .ssh/authorized_keys && chmod 600 .ssh/authorized_keys"

#+END_SRC



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:



#+BEGIN_SRC sh

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

#+END_SRC



Now copy it to the techela account like this.

#+BEGIN_SRC sh

cat ~/.ssh/id_rsa.pub | ssh [email protected] "cat >> .ssh/authorized_keys"

#+END_SRC



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



#+BEGIN_SRC sh

ssh [email protected] ls

#+END_SRC



#+RESULTS:



** 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:



#+BEGIN_EXAMPLE

@students =

#+END_EXAMPLE



** 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:



#+BEGIN_SRC sh

git clone [email protected]:assignments/label

#+END_SRC



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

** TODO 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:.



** TODO 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 

#+BEGIN_SRC sh

git clone [email protected]:assignments/label

#+END_SRC



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



2. 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:



 #+BEGIN_EXAMPLE

@team-1 = userid1 userid2 userid3

 #+END_EXAMPLE



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



 #+BEGIN_EXAMPLE

repo team-project-1

    RW = @team-1

 #+END_EXAMPLE



** 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:

 #+BEGIN_SRC sh

git clone [email protected]:a/label



cd label

# Add files

git add files

git commit files -m "some message"

git push -u origin master

 #+END_SRC



 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.



 #+BEGIN_EXAMPLE

repo student-work/label/userid-label

    RW = userid

 #+END_EXAMPLE



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



 #+BEGIN_SRC sh

git add conf/student-work

git commit -m "add new assignment repos"

git push

 #+END_SRC



 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.



 #+BEGIN_SRC sh

ssh [email protected] perms + READERS @students

 #+END_SRC



 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.



 #+BEGIN_SRC sh

git clone [email protected]:a/label

cd label

git remote rename origin src

git remote add origin [email protected]:student-work/label/userid-label

 #+END_SRC



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

 #+BEGIN_SRC sh

git add *

git commit -am "Turning work in"

git push -u origin master

 #+END_SRC



*** 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.



 #+BEGIN_EXAMPLE

repo student-work/label/userid-label

    R = userid

 #+END_EXAMPLE



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



 #+BEGIN_SRC sh

git add conf/student-work

git commit -m "add new assignment repos"

git push

 #+END_SRC



 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.



 #+BEGIN_SRC sh

cd student-work/label/userid-label

git clone [email protected]:student-work/label/userid-label

cd user-label

git tag -a turned-in -m "Work turned in by student" 

 #+END_SRC



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



 #+BEGIN_SRC sh

git tag -a graded -m "graded" 

git add *

git commit -am "Finished grading"

git push --tags -u origin master

 #+END_SRC



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