Moodle book and GitHub: working together

A major aim of the Moodle Open Book project has been to connect the Moodle Book module with GitHub. The intent was that such a connection would enable the easy sharing of content that is currently largely locked within the LMS, not to mention improving the authoring process for the Moodle Book module. Earlier this week I gave a presentation in which I demonstrated a working connection between the Book module and GitHub. The following post illustrates how this connection works.

This connection is implemented as a Moodle book tool, i.e.  an extension to the Moodle Book module that can be installed on any current version of Moodle. The code for the GitHub tool is available from this GitHub repository. The current status of this code is that it works, but is ugly (as the screenshots below will illustrate) and incomplete. The intent is that to get a working first version contributed to the Moodle Plugins database by early 2016 (end of January hopefully).

This work is funded by the USQ Open Textbook Initiative.

What is github?

If you don’t know what GitHub is, then I suggest you take the time to read the following or anyone of the many other resources on the web that explain GitHub.

Summary of how it works

The Moodle Book github tool currently works by

  1. Connecting a single “book” (a collection of web pages) created using the Moodle book with a single HTML file in a GitHub repository.
  2. The tool keeps a track of the relationship between the “book” and the HTML file and tells you if they are the same or different.
  3. Provides the ability to
    1. push the content of the “book” onto GitHub, and
    2. pull the content of the GitHub file back into the “book”.

Once the content of the book is on GitHub, this means it can be shared, modified, and updated by anyone via any means.

Hopefully it might become common for other people using Moodle to use the Book github tool to import books authored by someone else from GitHub into their Moodle course.

I’m certainly looking forward to being able to create and modify Moodle books outside of Moodle and using GitHub to migrate my changes back into Moodle.

Demonstration of how it works

The following contains a range of cropped screen-shots illustrating how the tool currently works. Click on any of the images to see a larger version.

A Moodle Book

First, let’s start with a Moodle book.  Here’s what one looks like in my course site.

001 Moodle Book and github

It’s just a collection of web pages.  But it does provide the Table of Contents and the “next page” and “previous page” navigation. It’s also a full part of Moodle hence services like activity completion can be used.

Make a change

Let’s make a change to this Moodle book.

002 Moodle Book and github

Can you see the rather pointless change (“**** SHOWING OFF GITHUB TOOL ****”) that I made to that page? Let’s assume that this change is important and responds to the experience of learners.

Is the Book github tool installed?

I want to save this change and the book to GitHub.  To do this the Book github tool needs to be installed.  Is it?

To find this out I look at the Book adminstration menu, which on my institutions Moodle theme looks like this.  Can you see evidence of the GitHub tool?

003 Moodle Book and github

Create the connection between book and github

To create (or check) the connection between the book and github I click on the GitHub link.

Authorise with your GitHub account

The first time you click on the GitHub link within Moodle, you will be redirected to GitHub and will see something like the following

004 Moodle Book and github

The github tool assumes that you have a user account on GitHub. This step is the github tool asking you for permission to use your GitHub account. Everything the github tool does on github will be done using this account.

If you agree to this you will see the connection page. This page allows you to configure the connection between the book and github, and also to view the status of that connection.  Here’s some of what I see.

Under construction: The current interface for the tool is very much under development. What you see is the minimal interface necessary to get all this working.

005 Moodle Book and github

In this case a connection has already been established.

In it’s current state the github tool expects you to provide two components for the connection

  1. the name of the GitHub repository; and,
  2. the full path to the specific file within the repository to connect with.

Currently the tool then combines these two bits of information with your GitHub username to arrive at the location of the file within GitHub.

I could change the connection to point another file on GitHub, but I’ll stick with this one.

Under construction: At the very least the ability to specify the github username and perhaps the branch (or similar) for the github file needs to be added.  Perhaps the option to copy and paste a github URL and have it checked and parsed?

View the file on GitHub

My username on GitHub is djplaner which means that the URL for the file that this book is connected to is http://github.com/djplaner/ICT-and-Pedagogy/Copyright.html.

If you click on that link, you can see the current status of the file on GitHub. When I wrote this, the file on GitHub looked like the following

006 Moodle Book and github

The book is a sequence of web pages. When pushing a book onto GitHub the Book github tool combines all of those web pages into a single HTML file. That HTML file includes some additional HTML to help the Book github tool pull the content back into the book.

Under Construction: The format/structure of the HTML produced by the Book github tool’s export/import is still undergoing some refinement. Use of HTML5 semantic tags is on the list.

View the file as a web page

If you look closely at the image above of the github tool showing the connection you should see

View the file as a web page.

If you click on that link you will see something like the following (depending on what changes I’ve made since I took this screenshot)

007 Moodle Book and github

Under Construction: This uses a free service to display a GitHub file as a web page. How this is done also requires a bit more work.

Under Construction: At the moment the HTML is a simple concatenation of the book pages. Very soon this will be modified to include some additional markup and some basic style sheets. The aim is that when you view this HTML page you will see a table of contents and be able to navigate it like a book.

What’s the status of the connection?

Underneath the details of the connection the Book github tool page shows a simple summary of the status of the connection. In the image above, the status is

The book has been revised since the last push.

This is because of the change I made to the book earlier in this post. That change means that the GitHub file is now out of date. It’s not the latest version of Book.

Update the GitHub file

At this stage I can decide whether or not I want to update the file. When and if I update GitHub file will be entirely up to me, the source of the book I’ve edited, the changes I’ve made etc.

But if I do wish to update the GitHub file, I hit the “Push” link and see something like the following.

008 Moodle Book and github

First, there’s a brief warning just to make sure that you know that pushing will probably make the content of the book open to all to see.

Second, there is a space to enter some details (a comment) about the changes you are about to push onto GitHub.  The details about the push are visible in both GitHub and the Book github tool. The details about the push are useful for understanding what changes are being made.

Once I’ve entered my comment, I hit the push button and hopefully see a report of a successful push.

009 Moodle Book and github

This means that the GitHub file has been changed.

View the file on GitHub

If I view the file on GitHub, that change should be visible in the change below

010 Moodle Book and github

The first change is that the comment/details I added about the push is visible in the row with the blue background (“Just showing off for the blog post”). That row includes my username, avatar, and how long ago the change was made. The second change is that the HTML for the file now contains the change I made in the Moodle book up above. I’ve highlighted it in green to highlight it.

View the change history

If I return to the Book github tool to view the connection, I can see the following

011 Moodle Book and github

The Status has been updated to indicate that the Book and the GitHub file are now the same.

You can also see that the “Change History” for the connection now includes the same comment/details (“Just showing off for the blog post”) that showed up on GitHub. Can you see the link “commit details” in the Change History?

The link takes me to GitHub and shows me the following colour coded summary of the changes that were made to the file by this commit.

012 Moodle Book and github

The green and red colours are used to indicate the additions (79) and deletions (128) made by this commit. This is much higher than you’d expect from the simple change I made.  This is because I’ve been playing with the code.

Note: you should be able to click on the link and see the same page. Even though I’ve subsequently made changes to the file on GitHub, I (and you) can always take a look at what the file looked like at this particular point in time.

View the file on my computer

So far we’ve been using the Moodle book and GitHub to view and change the file. There are GitHub clients for a wide array of software and hardware. For example, there is a GitHub application for Mac OS X that I can use to make a local copy of the GitHub repository on my computer.

The following image is an example of a Mac finder window showing my local copy of the repository.  It shows that the version of the Copyright.html file (the one we’re using for the Moodle book) was created and modified yesterday.

013 Moodle Book and github

With the repository files on my computer I can then use all my normal applications to edit and view the file.  If I double click on the Copyright.html file in Finder, this is what I see.

014 Moodle Book and github

Note that the “SHOWING OFF” message is missing.  That’s because the copy on my computer is behind that on GitHub.

Update it

To fix this I use the GitHub desktop tool to pull the latest content from GitHub to my computer. Having done that I see the following when I view the Copyright.html file on my computer

015 Moodle Book and github

All up to date

Make a change

The change I made to the file is silly. I can’t leave it there, I need to remove it.  There are currently three methods I could use to make this change:

  1. Directly on GitHub.
    GitHub provides a means by which to directly edit the files via the GitHub website.
  2. Using the Moodle Book.
    I could go back to Moodle book where I first made the change, delete what I added, and then use the Book github tool to push it back to GitHub (and then pull the change to my computer).
  3. On my computer.
    Change the file on my computer, use the Desktop GitHub tool to push that change back to GitHub, and then use the Book github tool to pull the change back into the Book

I’m going to use the last option.

Due to my age and background, I use the vim editor to edit HTML

016 Moodle Book and github

But you could use any HTML editing tool you wished to make the change.

Push it back

Time to push these changes back to GitHub using the Mac GitHub application.

017 Moodle Book and github

Note how the application does a very nice job of highlighting the change I’ve made.  The text I removed is highlighted by the dark red background.

Just like with the Book github tool, I get the chance to enter a some details/comment about the change I made.  In this case, “Remove the showing off”

Check GitHub

On GitHub the file now looks like the following

018 Moodle Book and github

Can you see that the message within the blue background row has changed to “Remove the showing off”.  The message I used on my Mac to commit the change.

What’s the status of the connection

Let’s head back into Moodle and the Moodle book github tool to check the status of the connection between the book and the github file

019 Moodle Book and github

As you can see “The GitHub file is ahead of the book.” and you can also see that the “Change History” is now headed by the message “Remove the showing off”.  Matching the message shown on GitHub in the previous image.

Pull

In order to update the Moodle book with this new content, I need to pull the data from GitHub into the book. Click on Pull and see the following warning

020 Moodle Book and github

The pull process will replace the existing content of the book with the content from GitHub, hence the need to be sure.  I’m happy with that so go ahead and Pull

021 Moodle Book and github

If I check the status via the Book github tool it will show green – the book and the github file are the same.

View the change

And back to look at the book to see that the change has been made

022 Moodle Book and github

What’s yet to be done

Coding

More work is required to get a version 1 ready use. There are a few “under construction” indicates listed above and a list of issues on the tool’s GitHub repository.

Anything missing?  Then let me know, or better yet, fork the tool repository, make the change, and generate a pull request

Use

Once version 1 is complete, the task will be to get it installed within the institution and then start working with people who want to use it. In particular, explore how it might be used within my institution to transform current practices.

Testing the Lucimoo epub export book tool

There’s movement afoot. The Lucimoo epub export tool for the Moodle book module is going through the process of being tested (and perhaps installed) on my institution’s main Moodle instance. What follows is a bit of testing of that tool in the institution’s test environment.

Verdict: all works, a few changes to practice to leverage it properly.

Import a few books

First step is to import a few books into the bare course site within the test environment. Just a few random books from my main course. Something that’s much easier now that @jonof helped identify some lost knowledge (and my oversight/mistake).

Of course it is never perfect. The default setting on the test environment is to use the gui editor. Which removes links to CSS files. Which is a real pain.

Doing an export

Once in the book select the administration/settings block and hey presto, there’s the option to “Download as ebook”

export

Select that option and I get the option to download the ePub file or view it in iBooks.

As reported earlier the ePub contains a few errors because apparently the original HTML content in my Book resource doesn’t always meet ePub’s stricter requirements. The bugs I had to fix included

  • Missing ending tag for an image (produced by ImageCodr)
    Of course it appears that the over-reaching default HTML editor in Moodle is automatically removing the /> I’m putting at the end of the <<img tag. I've had to change my preference to the plain text area to get that fixed.

    God I hate tools that assume they know better than I what I want to do and won't let me override their assumptions.

  • It appears that it doesn’t like the nbsp entity either.
    There appears to be some blather about this online, but I don’t have the time to fix it. For now I’ll remove the nbsp entities.
  • “Opening and ending tag mismatch: br line 0 and div”
    Replace <br> with <br />

    And all this so far is largely in code auto-generated by ImageCodr

  • “Opening and ending tag mismatch”
    An issue with the relationship between P and BLOCKQUOTE tags that I am somewhat lazy. Yay, that’s the first page.
  • The spacing around the image isn’t great.
  • “Specification mandate value for attribute allowfullscreen”
    A YouTube embed that doesn’t meet expectations.
  • The videos don’t show.
    There is a space for the embedded YouTube video, but it is empty. Will need to figure out a way to fix this. Especially in this test book, which has a lot of videos in it
  • Missing styling.
    In this books I use a bit of CSS to style elements such as activities. The ePub version is currently not showing that styling, though the “Print this book” version does. Ahh, that’s caused by the magical CSS chomping GUI editor. Fixed.

You can view the final ePub file and also a PDF produced by “printing the book”.

The layout of the PDF isn’t great. It does at least show some visual evidence of the videos. Though it’s not very useful.

Test the Assessment book

Assessment is of course what is uppermost in the minds of students, so I should test that book. I don’t have that in my nice offline format, so will have to explore the how Moodle backup and restore process.

Again, a slightly different collection of HTML “strictness” problems. Given the size of the assessment book, there are surprisingly few of them.

The major problem here is that my “macro” approach that relies on jQuery to update due dates and related information obviously won’t work with ePub. Wonder if the filter approach will work with the ePub export tool?

View the results on a mobile device

One of the main benefits of the ePub format is that it is supposed to play nicely with mobile devices. Hence testing the files on a mobile device (my phone) would be sensible. Observation and problems include

  • The Flickr image on the front page isn’t showing up. There is a link I can click on, but not embedded in the book. Wonder if that’s a config option in ibooks?
  • The CSS styling on tables for Assessment doesn’t appear to work.
    It does in iBooks on the laptop, but not on the phone. In much the same way that the images work on laptop, but not phone.
  • Neither does the table of contents, actually that appears to be an issue with internal links being added into the ToC and some of these being incorrectly.

Problems to be explored at a later date, not show stoppers, just part of learning the details of a new ecosystem.

Bringing github and the Moodle book module together – step 1

The following is the first step in actually implementing some of the ideas outlined in an earlier post about bringing and the Moodle Book module together. The major steps covered here are

  1. Explore the requirements of a book tool.
  2. Name and set up an initial book tool.
  3. Figure out how to integrate github.

A book tool

The Moodle book module is part of core Moodle. Changing core Moodle is (understandably) hard. Recently, I discovered that there is a notion of a Book tool. This appears to be a simple “plugin” architecture for the Book module. People can add functionality to the Book module without it being part of core. The current plan is that the github work here will be implemented as a Book tool.

What does that mean? My very quick search doesn’t reveal any specific information. The book tool page within the list of plugin types in the Developer documentation is missing. Suggesting that perhaps what follows should be added to that page.

The plugin types page describes book tools as

Small information-displays or tools that can be moved around pages

Which is perhaps not the best description given the nature of the available Book tools.

The tool directory

The book tools appear to reside in ~/mod/book/tool. Each tool has it’s own directory. Apparently, with all the fairly common basic requirements in terms of files

etc.

The Book module’s lib.php has various calls to get_plugin_list(‘booktool’) in various places

  • book_get_view_actions
  • book_get_post_actions
  • book_extend_settings_navigation

The first two look for matching functions (e.g. book_plugin_get_post_actions) in the book tool’s lib.php which get called and then used to modify operations.

The settings navigation is where the changes to the settings/administration block get made and from there that’s how the author gets access to the booktool’s functionality.

Naming and getting it started

The plan seems to be to

  1. Create a new github repository for the new book tool
  2. Copy and edit an existing book tool to get started.
  3. Figure out how to slowly add github functionality.

Creating the booktool github repository

The repository will need to be called moodle-booktool_pluginname. What should the plugin name be?

I’ll start with github. Existing tools tend to include a verb e.g. print, exportepub, importepub, exportimscp. So this may be breaking a trend, but that can always be fixed later.

And then there was a repository.

Clone a local copy.

Copy the contents from another book tool and start editing

And take a note of work to do on the issues section of the github repository.

Updated the icon. Wonder if that will work as is?

Login to local moodle. It has picked up the new module and asking to install. That appeared to work. Now what happens when I view a book resource? Woohoo that works.

Doesn’t do anything useful beyond display the availability of GitHub (with the nice icon).

Early success

Push that code back to the repository.

How to integrate github

Time to actually see if it can start talking to GitHub and how that might be achieved.

Initial plan for this is

  1. Hard code details of github repository and credentials for a single Book module.
  2. Implement the code necessary to update the link in the settings block based on whether the book is up-to-date with the repository.
  3. Implement index.php function to display various status information about current repository and book.
  4. Implement the fetch and push functions.

    From here on a lot more thought will need to be given to the workflow.

  5. Implement the interface to configure the repository/credentials

Which all beg the question.

How to talk to the GitHub API

The assumption underpinning all of this is that the tool will use GitHub API to access it’s services. Moodle is written in PHP, so I’m looking for a PHP-based method for talking to the GitHub API.

There’s no clear winner, so time to do a comparison

  • Scion: Wrapper – initial impressions good. Does use cURL. But requires other “scion” based code
  • KnpLabs API – requires another library for the HTTP requests. Not a plus.
  • tan-tan-kanarek version – looks ok. No mention of other requirements.

Let’s try the latter. Installation and it’s all working. Now only need to grok the API and how to use it from PHP.

The focus here is on an individual file. The book will be connected to an individual file.

Most of these request seem linked to the Contents part of the API – part of Repositories.

Actions required

  1. Does the file exist in the repo?
    Getting the content should return a 200 status code and “type: file” if it is a file, but it will also return the content of the file.
  2. Create a new file
    API: PUT /repos/:owner/:repo/contents/:path
  3. (fetch) Get the content for the file.
    API – GET /repos/:owner/:repo/contents/:path
  4. (push) Update the file with new content.
    API: PUT /repos/:owner/:repo/contents/:path
  5. What is the status of the file in the repo?
  6. What is the relationship between the content/status of the file in the repo and the content in the book.

Running out of time. Will have to come back to this another day for Step 2.

How might github and the Moodle book module work together

The Moodle open book project is attempting (not surprisingly) to modify the Moodle book module to enable it to produce open resources (educational or otherwise). The main focus is on making the content of the books open in a way that enables modification and reuse. The plan is to do this by enabling a Moodle book resource to be linked to github.

The following is an exploration of and an attempt to describe how this might work at a fairly high level.

What do you think? Might this work? Are there better options?

The next step will be to try some realistic technical explorations to see if this can be implemented.

Why?

The idea is that once in github different people (or courses) can use github to modify and collaborate around the same document. e.g. a book I created for my course, might be useful for another course looking at ICT and Pedagogy. Rather than play around with Moodle backups, I could create a github repository and the content of the book to that repository. The author of the other course can then fork that repo and import the content of the book from their repo into Moodle.

Any changes that either of us make to the book are stored in github. We can then use github’s features to share and manage changes.

Beyond this, I could make all of the books in my course available via github. Who knows, some of my students might find them useful or may wish to make changes that might enhance the work.

Implementation

At this stage, the idea is to implement the github ‘connection’ as a book tool. This means it can be installed by each Moodle site that wants it. When installed there will be a new link in the Book administration block through which you access the github functionality.

The intent is that an individual Book resource will be linked to a single file hosted in a github repository. The file would be a single HTML file (at least initially) with the different chapters and sub-chapters indicated in some yet to be defined way. The final format will aim to allow the HTML file to be edited by as many different editors as possible, but still allow simple importation into the Book module.

As a future feature, it might be possible and useful to all the import/export of that single file from github into the Book to be done using the user’s choice of other import/export tool. i.e. if I might want the file in github to be an epub file, I would configure the github tool to use the Lucimoo EPUB export/import tools to produce the file that is sent to/from github.

What it might look like

Initially, it might look like the following. The (off) is meant to be an indication that the connection to github is currently off. i.e. not being used.

001_off

Clicking on the GitHub link would open up a form that would be used to configure the necessary information including:

  1. github repository – that contains the file.
  2. file – the actual file being linked to.
  3. github credentials – of the author (with the option that this might be left empty for repositories configured to allow that).
  4. behaviour spec – i.e. how to import the file (replace existing content, append?), how to handle changes made in the book

    Initially, this would probably be left to some default combination. It would also be dependent on the settings of the repository and the permissions of the github credentials.

    More work required here.

Once this is configured, the administration link would change to indicate that a connection had been made. It would now have a link to the file on github and also some indication of the relationship between the book and the github file. In the following image “clean” implies the book and github file are a match.

002_on

If changes are made in the Moodle book this would mean that the book is “ahead” of the github file. The github link would change appropriately. It would also add an additional link “push”. Clicking on that link should probably display a page that provides some details of the changes to be pushed and allows the author to make the choice whether to push or not.

003_push

If the version of the file on the repository had been changed, then changes are also made.

004_out_of_date

Leaving the question of what happens when both local and remote changes have been made? Both? Some thought to be given here.

005_both

Assumptions

This is all based on

  1. The Book author has the details and credentials to a GitHub respository that contains a file of the correct format;
    This might be a challenge for some authors.
  2. There is no local git repository.
    Asking folk supporting a Moodle instance to install git on the server is a bit much. Instead, the content for the book will be stored in the Moodle database. No problems for Moodle, but raises questions about how to determine whether there have been changes. At least two current possibilities

    1. Store the date of last change on the repo in the Moodle database and compare dates for changes to the book.
    2. Generate/store a version of the HTML file locally and do a compare (sounding very heavyweight).
  3. That different books in a single course could be linked to entirely different github repositories.
  4. That the idea of adding additional links and status information about github into the administration block doesn’t break some Moodle style guide.
  5. Outstanding questions

    Lots.

    More specifically

    • How to handle links between chapters?
      A book is made up of chapters (a single HTML page). When displayed in Moodle the Book module provides simple next/previous page navigation. It’s also fairly common for authors to hard-code links between chapters (and even into chapters in other books). If the github version of a book stores all the chapters in a single file, what about these links?

      How do the existing export/import plugins handle this?

    • How to handle embedded resources (images, movies etc)?
      Books also contain embedded images, movies etc. The issue of how these are provided is a common one. I tend to use external services, but others place them into Moodle, how to handle these? How do the existing export/import plugins handle them?
    • Is all of the above technically possible with github, the github API, PHP, Moodle etc.
    • Does all this need to be github specific? Is there a way (and a need) for this to git specific, but not github specific?
    • What might be the process for create a new file in a repository based on an existing Moodle book?

Re-using a #moodle course design

This semester I’m course examiner for a new course on Secondary Computing Curriculum and Pedagogy. As the name suggests, the course is intended to help pre-service teachers who are aiming to teach computing in Secondary schools. While I’m the course examiner, the course is being developed and will be largely taught by a couple of practicing and experienced Secondary computing teachers (how’s that for “recency of practice”?).

Two weeks before semester start my institution opens up the course sites for students to become familiar with what’s on offer. There are some minimum expected standards to meet. My task today is to meet those standards and in doing so set up the skeleton of the course site for the rest of the semester. To do this I’m going to reuse the structure from EDC3100, perhaps with a few tweaks. Besides saving me some time, four of the five students currently enrolled in the course have done EDC3100.

This is also a bit of an exploration of the difference between an empty Moodle course site (even one with a standard look and feel) and one with a structure.

What I’ll need to do

Can I list all I need to do

  • Structure of the site
  • Study Schedule
  • Assessment
  • Teaching team
  • The initial orientation message.

Structure

The basic structure is going to match the EDC3100 template. A collection of topics tied directly to each week of semester with a “jump to” bar at the top of the course site. There will also be a collection of “adminstrative” topics.

The following image shows the top of the 2012 version of the EDC3100 site. In 2015 the institution has adopted a default course structure that does away with the need for the “Course Content” and “Course Background” boxes.

Welcome

The one question about this approach is that EDC3100 has quite a bit of content in each week. Not sure that EDS4406 will have the same quantity. Hence the separate topics for each week may be a bit of overkill.

As it stands each topic does have a formal title meaning it’s probably valuable to make use of the macro facility I’m using in EDC3100.

Process setting this up includes

  1. Copy the “course format” used in EDC3100.
    “Weekly format” with 12 sections. 10 teaching weeks + an orientation and a “resource” week.
  2. Update the names of each section/topic/week of the course.
    Using the macro facility the names entered into a moodle are in this form {{{W0_TITLE}}} ({{{W0_PERIOD}}}). A bit of Javascript will replace the “variables” with appropriate values.
  3. Put in place the Javascript file to do the translation.
    I’ll create a new one for this course. Copy the EDC3100 js file across and update the values. Week titles first. That’s all done. The problem with week numbers changing because of holidays reared it’s head again.
  4. Stick in the “jump to”
    Oh, that was nice. Copy the HTML from EDC3100, replace the course id, paste it into the EDS4406 site, and hey presto it all works. Even the tooltips get updated with the new topic names.

“Administrative” content – Study schedule, assessessment, and teaching team

These three sections are important but don’t form part of the students’ weekly learning activities. The institutional default course structure provides default tools for display this information, but IMHO they aren’t as useful as using a Moodle book to provide course specific information.

At this stage, the detailed information for these sections isn’t yet written, I’ll just be putting in the initial skeleton. That involves

  1. Creating a Moodle book resource for each section.
  2. Updating the js file to point the default course structure links to these books.
  3. Put in some basic information into the books.

Again the macro system is nice. Copy and paste some HTML from the EDC3100 book that is using the macro approach. Link in the EDS4406 js file and the content automagically updates to EDS4406 information.

Orientation message

This will need to be a little more than a message. Will work on that tomorrow and update this.

And the little one said, “roll over, roll over”

Roll over

It’s that time of year again. The time between semesters when one offering of the main course I teach is still drawing to a close and when I have to think about preparing for the next offering. It’s time – for better or worse – to roll over. The following is a description and some thoughts on how and what I do during roll over.

As it happens there is some discussion going on in the Moodle community about “roll over”, but at the institutional level. The following is very much focused on the course level.

The process

The high level steps I use are:

  1. Use the Moodle/institutional roll over process.
  2. Update my “macros”.
  3. Check for broken links.
  4. Other manual changes

Overall, the tools provided by the institution to roll over a course from one semester to the next do a reasonable job. However, if you have a fair amount of structure and content to a course site there is a hole. The tools don’t yet know enough about the institutional context (dates, weeks). Nor is this information provided in a way that helps teaching staff integrate the information in a way that responds to those changes. The problem gets worse the more you get into the unique course context (e.g. names of weekly topics).

Moodle/institutional roll over

I log an IT request (using a god awful interface) and in a little while some magic happens and the content from Semester 1 (S1) is copied into the Semester 2 (S2) course. The image below (click on it to see it larger) is of the newly rolled over S2 course site. As it shows – for better or worse – the course has quite a collection of resources that make up each weekly learning path (originally called and based on the idea of a weekly ramble). The interconnections between each of the elements is quite convoluted. e.g. the “Introduce yourself” book links to the “Share your introductions” discussion forum and vice versa.

The Moodle/institutional roll over process does a really good job of updating the interconnections between elements. This is good.

But there’s a problem. Can you see the problem in the following image?

s2 2015

Semester 2 runs from late July through to October/November. The dates in the above image are different. They are for Semester 1. The Moodle roll over process doesn’t know anything about USQ dates. This causes problems because dates are littered throughout the course site. Such as the assessment overview page, each individual assignment page, the study schedule, and any of the learning path pages that mention dates.

The suggestion is that I need to manually search (remember there’s typically no search engine on a Moodle course site) and replace all occurrences of dates and any other information that may change from offering to offering. Information that might include:

  • the details of the teaching staff;
    e.g. the assessment information contains directions to “email the course examiner” with extension requests. Who is the course examiner may change from offering to offering.
  • names of weeks/topics; and
    In the above image, week 1 goes under the title “ICT, PLNs and You”. I may wish to change that topic name in Semester 2 (e.g. add in the missing comma “ICT, PLNs, and You”) and the course material uses the topic names throughout.
  • the weeks of the semester for each topic.
    For some historical reason, when it numbers the weeks of semester my institution includes weeks that are holidays in the count. Since holidays are never at the same time each semester, it means for some topics their week of semester changes. In Semester 1, the “Finishing your UoW” topic is in Week 8. In semester 2, it will be Week 6.

“Macros” – my solution to this problem

Last semester I implemented a “macro” system. Initial implementation had it working just for the semester 1 site. Time to update it to work with both sites. The Javascript code will no need to

  1. Identify which course site (S1 or S2) the user is viewing.
  2. Replace all the “macro” variables with values appropriate to the course site.

What I need to do know is enter appropriate information for the new offering, this includes

  • links to books within the course site;

    Assessment, study schedule etc.

  • Assignment due date – course profile.
  • Professional experience dates – PE calendar
  • Weeks and dates – academic calendar.
    This also involves moving the holidays and week numbers around.

With the script updated viewing the S2 course site now reveals the following. Dates and weeks updated.

S2 2015

Broken links

The institution has a “check course” tool that performs a range of checks. Problems it picked up in the newly rolled over course included

  • Cross-course references
  • Reference to missing activity

22 problems were identified, all to be fixed manually. Most were due to the tweaking of paths I did last semester which broke links.

Other manual changes

Teaching team details – need to remove the folk who aren’t teaching in S2. The institutional system for “teaching team” does this automatically, but it has some missing functionality, including

  • No space to add a “Advice on specific request” section.
    i.e. when students are looking for how to contact the teaching team, they often want to ask the same question. A section like this allows some additional advice and scaffolding.
  • No space for “personalisation”.
    The institutional version only offers the standard contact details and qualification information that is present in the institutional database. It doesn’t allow a staff member to personalise their part of the course site. e.g. to explain exactly what they do in the course and more importantly take a small step in creating a relationship with the students.

Week order for study schedule and “jump to” – the change in week numbers for specific topics needs to be manually adjusted. That’s done, but a problem

Build the scaffolds

A number of the activities are based around discussion forums. Students have to complete an activity and share the end result in a forum. Many of these includes example responses (often only seen after the student posts their response). Most of these come from other students in the offering, but a small number are provided by me. I need to manually copy these over from the last offering.

But it appears that the institutional SSO is playing silly buggers. Will have to complete that task later.

Revisiting the IRAC framework and looking for insights

The Moodlemoot’AU 2015 conference is running working groups one of which is looking at assessment analytics. In essence, trying to think about what can be done in the Moodle LMS code to enhance assessment.

As it happens I’m giving a talk during the Moot titled “Four paths for learning analytics: Moving beyond a management fashion”. The aim of the talk is to provide some insights to help people think about the design and evaluation of learning analytics. The working seems like a good opportunity to (at some level) “eat my own dogfood” and fits with my current task of developing the presentation.

As part of getting ready for the presentation, I need to revisit the IRAC framework. A bit of work from 2013 that we’ve neglected, but which (I’m surprised and happy to say) I think holds much more promise than I may have thought. The following explains IRAC and what insights might be drawn from it. A subsequent post will hopefully apply this more directly to the task of Moodle assessment analytics.

(Yes, Col and Damien, I have decided once again to drop the P and stick with IRAC).

The IRAC Framework

Originally developed to “improve the analysis and design of learning analytics tools and interventions” and hopefully be “a tool to aid the mindful implementation of learning analytics” (Jones, Beer, Clark, 2013). The development of the framework drew upon “bodies of literature including Electronic Performance Support Systems (EPSS) (Gery, 1991), the design of cognitive artefacts (Norman, 1993), and Decision Support Systems (Arnott & Pervan, 2005).

This was largely driven by our observation that most of the learning analytics stuff wasn’t that much focused on whether or not it was actually adopted and used, especially by teachers. The EPSS literature was important because an EPSS is meant to embody a “perspective on designing systems that support learning and/or performing” (Hannafin, McCarthy, Hannafin, & Radtke, 2001, p. 658). EPSS are computer-based systems intended to “provide workers with the help they need to perform certain job tasks, at the time they need that help, and in a form that will be most helpful” (Reiser, 2001, p. 63).

Framework is probably not the right label.

IRAC was conceptualised as four questions to ask yourself about the learning analytics tool you were designing or evaluating. As outlined in Jones et al (2013)

The IRAC framework is intended to be applied with a particular context and a particular task in mind. A nuanced appreciation of context is at the heart of mindful innovation with Information Technology (Swanson & Ramiller, 2004). Olmos & Corrin (2012), amongst others, reinforce the importance for learning analytics to start with “a clear understanding of the questions to be answered” (p. 47) or the task to be achieved.

Once you’ve got your particular context and task in mind, then you can start thinking about these four questions:

  1. Is all the relevant Information and only the relevant information available?
  2. How does the Representation of the information aid the task being undertaken?
  3. What Affordances for interventions based on the information are provided?
  4. How will and who can Change the information, representation and the affordances?

The link with the LA literature

Interestingly, not long after we’d submitted the paper for reviewing, Siemens (2013) came out and that paper included the following Learning Analytics (LA) Model (LAM) (click on the image to see a larger version). LAM was meant to help move LA from small scale “bottom-up” approaches into a more systemic and institutional approach. The “data team” was given significant emphasis in this.

Siemens (2013) Learning Analytics Model

Hopefully you can see how the Siemens’ LAM and the IRAC framework, at least on the surface, seem to cover much of the same ground. In case you can’t, the following image (click on it to see a larger version) makes that connection explicit.

IRAC and LAM

Gathering insights from IRAC and LAM

The abstract for the Moot presentation promises insights so let’s see what insights you might gain from IRAC. The following is an initial list of potential insights. Insights might be too strong a word. Provocations or hypothesis might be better suited.

  1. An over emphasis on Information.

    When overlaying IRAC onto the LAM the most obvious point for me is the large amount of space in the LAM dedicated to Information. This very large focus on the collection, acquisition, storage, cleaning, integration, and analysis of information is not all that surprising. After all that is what big data and analytics bring to the table. The people who developed the field of learning analytics came to it with an interest in information and its analysis. It’s important stuff. But it’s not sufficient to achieve the ultimate goal of learning analytics, which is captured in the following broadly used definition (emphasis added)

    Learning analytics is the measurement, collection, analysis and reporting of data about learners and their contexts, for purposes of understanding and optimising learning, and the environments in which it occurs.

    The point of learning analytics is to find out more about learning and the learning environment and change it for the better. That requires action. Action on part of the learner, the teacher, or perhaps the institution or other actors. There’s a long list of literature that strongly argues that simply providing information to people is not sufficient for action.

  2. Most of the information currently available is of limited value.

    In not a few cases, “big data is driven more by storage capabilities than by superior ways to ascertain useful knowledge” (Bollier & Firestone, 2012, p. 14). There have been questions asked about how much the information that is currently captured by LMSes and other systems can actually “contribute to the understanding of student learning in a complex social context such as higher education” (Lodge & Lewis, 2012, p. 563). Click streams reveal a lot about when and how people traverse e-learning environments, but not why and with what impacts. Beyond that is the problem raised by observations that the use of e-learning by most courses does not make particularly heavy or well-designed use of the learning environment.

  3. Don’t stop at a dashboard (Representation).

    It appears that most people think that if you’ve generated a report or (perhaps worse) a dashboard you have done your job when it comes to learning analytics. This fails on two parts.

    First, these are bad representations. Reports and many dashboards are often pretty crappy at helping people understand what is going on. Worse, these are typically presented outside of the space where the action happens. Breaking the goal of an an information system/EPSS i.e. “provide workers with the help they need to perform certain job tasks, at the time they need that help, and in a form that will be most helpful” (Reiser, 2001, p. 63).

    Second, just providing data in a pretty form is not sufficient. You want people to do something with the information. Otherwise, what’s the point? That’s why you have to consider the affordances question.

  4. Change is never considered.

    At the moment, most “learning analytics” projects involve installing a system, be it stand alone or part of the LMS etc. Once it’s installed it’s all just a better of ensuring people are using it. There’s actually no capacity to change the system or the answers to the I, R, or A questions of IRAC that the system provides. This is a problem on so many levels.

    In the original IRAC paper we mentioned: how development through continuous action cycles involving significant user participation was a core of the theory of decision support systems (Arnott & Pervan, 2005) a pre-cusor to learning analytics; Buckingham-Shum’s (2012) observation that most LA is based on data already being captured by systems and that analysis of that data will perpetuate existing dominant approaches to learning; the problem of gaming once people learn what the system wants. Later we added the task artifact cycle.

    More recently (Macfadyen et al 2014) argue that one of the requirements of learning analytics tools is an integrated and sustained overall refinement procedure allowing reflection” (p. 12).

  5. The more context sensitive the LA is, the more value it has.

    In talking about the use of the SNAPP tool to visualise connections in discussion forums, Lockyer et al (2013) explain that the “interpretation of visualizations also depends heavily on an understanding the context in which the data were collected and the goals of the teacher regarding in-class interaction” (p. 1446). The more you know about the learning context, the better the insight you can draw from learning analytics. An observation that brings the reusability paradox into the picture. Most LA – especially those designed into an LMS – have to be designed to have the potential to be reused across all of the types of institutions that use the LMS. This removes the LMS (and its learning analytics) away from the specifics of the context, which reduces its pedagogical value.

  6. Think hard about providing and enhancing affordances for intervention

    Underpinning the IRAC work is the work of Don Norman (1993), in particular the quote in the image of him below. If LA is all about optimising learning and the learning environment then the LA application has to make it easy for people to engage in activities designed to bring that goal about. If it’s hard, they won’t do it. Meaning all that wonderfully complex algorithmic magic is wasted.

    Macfadyen et al (2014) identify facilitating the deployment of interventions that lead to change to enhance learning as a requirement of learning analytics. Wise (2014) defines learning analytics intervention “as the surrounding frame of activity through which analytics tools, data and reports are taken up and used”. An area of learning analytics that is relatively unexplored (Wise, 2014) and I’ll close with another quote from Wise (2014) which sums up the whole point of the IRAC framework and identifies what I think is the really challenging problem for LA

    If learning analytics are to truly make an impact on teaching and learning and fulfill expectations of revolutionizing education, we need to consider and design for ways in which they will impact the larger activity patterns of instructors and students. (Wise, 2014, 203)

    (and I really do need to revisit the Wise paper).

Norman on affordances

References

Arnott, D., & Pervan, G. (2005). A critical analysis of decision support systems research. Journal of Information Technology, 20(2), 67–87. doi:10.1057/palgrave.jit.2000035

Bollier, D., & Firestone, C. (2010). The promise and peril of big data. Washington DC: The Aspen Institute. Retrieved from http://india.emc.com/collateral/analyst-reports/10334-ar-promise-peril-of-big-data.pdf

Buckingham Shum, S. (2012). Learning Analytics. Moscow. Retrieved from http://iite.unesco.org/pics/publications/en/files/3214711.pdf

Hannafin, M., McCarthy, J., Hannafin, K., & Radtke, P. (2001). Scaffolding performance in EPSSs: Bridging theory and practice. In World Conference on Educational Multimedia, Hypermedia and Telecommunications (pp. 658–663). Retrieved from http://www.editlib.org/INDEX.CFM?fuseaction=Reader.ViewAbstract&paper_id=8792

Gery, G. J. (1991). Electronic Performance Support Systems: How and why to remake the workplace through the strategic adoption of technology. Tolland, MA: Gery Performance Press.

Jones, D., Beer, C., & Clark, D. (2013). The IRAC framwork: Locating the performance zone for learning analytics. In H. Carter, M. Gosper, & J. Hedberg (Eds.), Electric Dreams. Proceedings ascilite 2013 (pp. 446–450). Sydney, Australia.

Lockyer, L., Heathcote, E., & Dawson, S. (2013). Informing Pedagogical Action: Aligning Learning Analytics With Learning Design. American Behavioral Scientist, 57(10), 1439–1459. doi:10.1177/0002764213479367

Lodge, J., & Lewis, M. (2012). Pigeon pecks and mouse clicks : Putting the learning back into learning analytics. In M. Brown, M. Hartnett, & T. Stewart (Eds.), Future challenges, sustainable futures. Proceedings ascilite Wellington 2012 (pp. 560–564). Wellington, NZ. Retrieved from http://www.ascilite2012.org/images/custom/lodge,_jason_-_pigeon_pecks.pdf

Macfadyen, L. P., Dawson, S., Pardo, A., & Gasevic, D. (2014). Embracing big data in complex educational systems: The learning analytics imperative and the policy challenge. Research and Practice in Assessment, 9(Winter), 17–28.

Norman, D. A. (1993). Things that make us smart: defending human attributes in the age of the machine. Cambridge, Mass: Perseus. Reading, MA: Addison Wesley.

Olmos, M., & Corrin, L. (2012). Learning analytics: a case study of the process of design of visualizations. Journal of Asynchronous Learning Networks, 16(3), 39–49. Retrieved from http://ro.uow.edu.au/medpapers/432/

Reiser, R. (2001). A history of instructional design and technology: Part II: A history of instructional design. Educational Technology Research and Development, 49(2), 57–67.

Siemens, G. (2013). Learning Analytics: The Emergence of a Discipline. American Behavioral Scientist, 57(10), 1371–1379. doi:10.1177/0002764213498851

Swanson, E. B., & Ramiller, N. C. (2004). Innovating mindfully with information technology. MIS Quarterly, 28(4), 553–583.

Wise, A. F. (2014). Designing pedagogical interventions to support student use of learning analytics. In Proceedins of the Fourth International Conference on Learning Analytics And Knowledge – LAK ’14 (pp. 203–211). doi:10.1145/2567574.2567588

Analysing Moodle community forum discussions about the Moodle book module

As part of the “Moodle open book” project I’m hoping to increase my knowledge of what the Moodle community has already discussed about the Book module. The following is a summary of the process I’m using to analyse those discussions.

Not finished, but the story so far. Just over 2400 posts extracted from Moodle community forums that appear to mention “Book module”. About 250 posts (very roughly) coded so far. The following is a very early summary of the features discussed in those posts is

  • 43 – navigation and interface
  • 33 – export and import
  • 15 – printing
  • 13 – integrating activities (mostly quizzes) into the midst of the book.
  • 6 – page visibility
  • 3 – version control

Though a little interesting, I wouldn’t read to much into those figures yet. There are some more statistics on the 2400+ posts below.

Obtain the data

The process for obtaining the data was

  1. Global search for “book module”.

    Use the “Search forum” functionality in the “Moodle in English” community to search for posts that mentioned “book module”. This gave 144 pages of forum posts. These were than saved to my laptop.

  2. Get all the posts from the Book module forum.

    Got a copy of all the forum posts to Book module forum

Parse the data

Need to write a Perl script that will extract that information from the HTML files.

The potentially useful data in this set includes

  • Post
    • the subject line for the post (parsed)
    • body of the post (parsed)
    • date string when posted (parsed)
  • Forum
    • link (parsed)
    • name (parsed)
  • Author
    • User id
    • Author name (parsed)
    • link to their profile (parsed)

Stick it in (a) database table(s)

Next step is to have the script stick it all in a database table to ensure that there are no duplicates. moodle_book_forum_posts

That appears to be working. Now to try and get it all the forum posts inserted.

Done, some quick stats from SQL

  1. 2442 forum posts
  2. 870 authors
  3. 146, 71, 41, 41, 41, 41, 36 – the number of posts (in descending order) by the most prolific authors.
  4. the posts are from 40 forums.
    As you would expect, most in the book forum.

    • Book – 1774 posts
    • General help – 143
    • General developer – 86
    • Themes – 46
    • General plugins – 38
    • Gradebook – 37

    The presence of the gradebook forum potentially points to the biggest flaw with the data so far. i.e. search for “book module” my return posts that include “gradebook module” or similar. This will get ironed out in the later analysis.

  5. Content analysis – into NVivo

    The plan is to use NVivo to do a content analysis on the posts. The aim is to to identify the nature of the posts about the Book module. i.e. are the posts how to use, bug reports, feature requests etc. As part of that what types of features have been requested and when.

    The plan was to import the data from the database, but apparently the Mac version of NVivo cannot import data from a database. Meaning I need to go via a spreadsheet/CSV file.

    Sadly, Nvivo seems a little constrained. e.g. you can’t add to or change a dataset.

    But at least Perl and WriteExcel provide some flexibility.

    Of course, it appears that I have to load the Excel file produced by Perl into Excel and then save it from Excel before NVivo will import it properly.

    Initial analysis with NVivo

    First run through I think I’ll use these nodes

    • Book or NotBook – to indicate whether a post is related to the book module.
    • NewFeature – indicate something to do with new feature
      • Request – asking for a new feature
      • Announce – Announce a new feature
    • Bug – indicate a bug has been identified
      • Request – asking for help with a bug
      • Announce – announcing a fix for a bug
    • Help – getting help with using book
      • Request – asking for help
      • Announce – answering please for help

    Each of the book related nodes will have nodes indicating what is being helped with e.g. export, import, navigation, authoring, permissions, display. Wonder if there’s a list of these already.

    It’s taking a while to do this coding. Pity about the absence of decent keyboard shortcuts in NVivo.

    Will probably need to revisit these categories. Such as there are a few categories where the distinction is questionable – e.g. export/print, bug/new feature

An overview of the Moodle “open” book project

In another 50 minutes I’m off to attend the “First Open Textbook Community Meeting” made up of folk who were successful in getting an internal institutional grant for the USQ Open Textbook Initiative. One of the tasks we’re being asked is

Prepare a short overview of your intended project for your colleagues at the meeting

Hence this post attempting to develop some ideas for my project

The Moodle “open” book project

The main course I teach – EDC3100, ICT and Pedagogy – has no set text. Instead, the course site currently contains 73 resources created with the Moodle book module. Those 73 Moodle books include at least 670 “pages” of content, including both administrative and learning content. The core of those books is the “learning path”. A weekly path that guides learners through a range of literature, resources and activities intended to help them to design learning experiences where digital technologies (ICTs) are used to amplify and transform their students’ learning.

The aim of this project is to develop a framework (defined as collection of technologies, processes, and practices) that will help me transform these course resources. Transform these sad, lonely Moodle books withering away in the online ghetto that is the course site into open resources that can be read, modified, and re-used by anyone with an interest in ways that are appropriate for them. The intent is that once developed and tested with the EDC3100 resources, the framework will be available to anyone else using the Moodle LMS.

The inverse relationship between reusability and pedagogical effectiveness

There is no assumption in this project that the EDC3100 books represent some huge contribution to the literature on the integration of ICT into learning and teaching. There is no assumption that the resources are in anyway generic enough to be immediately reusable by people outside of the course. The EDC3100 books are written in a way to be very specific to the course and the course site. Immediately bumping into “The Reusability Paradox” proposed by David Wiley. The greater the pedagogical value a resource has for a particular context, the less potential for reusing the resource outside of that original context. Wiley identifies four possible solutions to this paradox

  1. create highly decontextualized resources that can be reused broadly but teach very little;
  2. we can build highly contextualized resources that teach effectively in a single setting but are very difficult to reuse elsewhere;
  3. we can shoot for the mediocre middle; or,
  4. allow and enable for contextual modification of the learning object.

This project is aiming to support the adoption of solution #4. The Moodle “open” book project is about transforming the EDC3100 resources (and any resources using the Moodle book) into resources that can be modified in response to contextual demands of anyone and everyone.

Concrete lounges and why basketball players aren’t better hockey players

Assignment 1 for my course is due later today. 100+ students have submitted. Time to explore the Moodle assignment submission system and how to allocate assignments to markers.

So what?

Why would that be interesting to anyone not using Moodle? Well because…

Is elearning like teenage sex?

One explanation for the quality of “e-learning” is

We have taken our teachers who have been really effective at face-to-face teaching and asked them to also be experts in online teaching. Get real! That’s like asking a good basket baller to become a good hockey player. Yes it’s sport and yes you have a ball and competitors, but the rules are very different. And yes, if you’re a good sportsperson, chances are you can pick-up on being good at another code, but it will take time and quite a bit of training.

”Die Schuhe sind zu groß.” - ”The shoes by Jorbasa, on Flickr
Creative Commons Creative Commons Attribution-No Derivative Works 2.0 Generic License   by  Jorbasa 

That’s certainly part of the problem. But – to extend the analogy – the other part of the problem that I experience day to day is that universities are asking the good basketball players to play hockey with equipment that’s quite a few sizes too small and simply doesn’t help them play hockey, let alone learn how to play hockey.

This is not to say that the provision of the appropriate equipment is easy. It’s not. It’s incredibly difficult. A wicked problem.

The point is that the perspective (from the same post) is – in my experience – not the case at all

We already have all the tools we need to get our students engaged. Sure there will be new ones that come along from time to time that will do things a wee bit better, but for the time being we have plenty to make this happen.

As a teacher engaged with e-learning at a University, most of the technology provided is a concrete lounge.

Assignment submission

My current institution has this year moved away from a locally produced online assignment submission and management (OASM) system toward one embedded within the Moodle LMS. There’s apparently been some customisation of the standard Moodle OASM system, but it’s not clear just how much. I’ve already heard reports from other staff (with courses that have assignments due before mine) that allocation of assignments to makers is less than easy.

The following documents my attempts to do this and seeks to explore if the Moodle assignment submission system will be an example of the wrong size shoes for playing hockey.

I’m a hockey player

Background: I designed and implemented my first OASM system back in 1994/1995. From then through to about 2004/2005 I led the design and implementation of various generations of an OASM system and wrote the odd paper about it. I know a bit about these systems. I’m not a basketball player, I’m a hockey player.

Assigning some assignments – do it myself

Documentation by mray, on Flickr
Creative Commons Creative Commons Attribution-Share Alike 2.0 Generic License   by  mray 

First test, can I figure out how to do this via the interface. i.e. don’t read the “manual”.

Assuming the “Assignment administration” menu would offer some insight/affordances.

“Marker assignment quota” seems the most obvious option. A couple of observations

  • Apparently one of the students has some how been allocated the role of marker, she is appearing in the list of markers.

    My first question is obviously, “How the hell did that happen?”. The user is currently assigned to both the student and “general admin” roles. I don’t remember (even accidentally) making this change. Wonder how it happened?

  • This offers a choice of unlimited or a specific quota, but isn’t pre-populated with data already entered.

    i.e. to employ the markers to do this work, I had to negotiate with them how many they could mark and then specify that in the contract process. Having to re-enter this data in another system is a bit of a pain. I understand why it hasn’t been done. These are two very separate systems managed by very different parts of the institution. But if the shoe were too fit…..

Concrete lounge #1: Having to re-enter data already present in other systems.

View/grade all submissions

Next bet is to try the “View/grade all submissions” which shows a filterable list of all the submitted assignments and allows a number of operations to be done upon them. I’m assuming that “allocate marker” could be one of them.

Yep, “set allocated marker” is an option. Select the student(s) to allocate, select the menu option and hit “Go”. Brings up a page with those students listed and another drop down menu of markers. You chose the marker and hit “Save Changes”

Two potential problems with this

  1. Pre-allocation; and

    This does imply that you can only allocate markers to assignments that have already been submitted. I’ve got at least one marker who has a fixed group of assignments to mark. All located at a specific campus. In a perfect world I’d be able to pre-allocate the assignments from those students to the marker. Rather than have to wait until they are submitted and manually allocate them.

  2. Manually selecting individual students.

    Individual allocation is ok, but I would like to see at least two additional options. First, the allocation by group option available above. Second, a random (or perhaps specific) allocation of specified numbers. e.g. I have markers who will make 50 assignments, I’d like to automatically allocate them 50 assignments and have the system randomly allocate them. I’d rather not have to count to 50.

    Even better, it might be nice to say allocate them 50 assignments, but aim to achieve a balance of ability levels (perhaps based on GPA or some other indicator). Few things are more depressing than having to mark 50 low quality assignments. I assume there would be other allocation schemes people would like to apply.

Are there other options beyond this?

Grading options

Under the “grading option” drop down menu there is a “auto-allocate markers” option. But I wonder if it’s smart enough to handle variety. i.e. I need to ensure that one marker gets all the students at one campus, but can randomly allocate the remainder.

I don’t want to experiment with this option, just in case it goes ahead and auto-allocates straight away. So I’ll do a Google search for documentation. The search results are not that clear.

It appears that Moodle 2.6 added two related features – marking workload; and, marking allocation. These have to configured into the assignment activity. Did I do this? I did indeed. And this provides the functionality I’ve already identified.

So let’s just suck it and see. Good, it doesn’t do this straight away. It allows the options to

  1. allocate all unallocated, submitted submissions;
  2. allocate all unallocated submissions (including unsubmitted ones);

    Both these options are dong be specifying an “allocation batch size” and either doing an “Allocate” or “Simulate”. The simulate is a useful feature.

  3. copy allocations from another assignment.

Nothing here about allocating based on groups.

Filters and options

There are a collection of filters that can be applied, based on

  • # assignments per page;
  • assignment status;
  • marker allocation;
  • workflow status;

    A slight duplication to assignment status, but based on a different approach.

There’s nothing here about filtering based on groups. Is this because I haven’t configured there to be?

Group options in the settings

There is a “Group submission settings” section in the assignment settings. But most of this is based on the idea of students submitting assignments in groups. Not using groups to allocate assignments to markers.

No obvious options

I’m giving up. I can’t see from the system any obvious ways to allocate assignments easily via groups.

At this stage it appears that I will have to

  1. Manually allocate all students at one campus to their marker.
  2. Use the auto-allocate feature for the remaining students.
Edu Doggy by David T Jones, on Flickr

In theory, I could negotiate with the first marker to do an auto-allocate. But I think it important that he mark the assignments of his own students. Changing that preference would be the case of the tail wagging the dog.

Use the documentation

Before I do that, let’s see whether the documentation provided by the institution can offer any insight. It appears that this might be the solution

However, if the assignment activity has first been configured into groups, these can be manually assigned to a specified Marker.

I’m not entirely sure what this means. Let’s experiment with a dummy assignment and use the “common module settings” and the groups there.

First, the groupings don’t seem to be appropiate. No option to do it at campus level.

Okay, this appears to have added an additional option to filter which students/assignments are shown based on groups.

This would provide the option I need (a bit of a kludge), but the question is whether or not the setting can be changed on the fly – i.e. after students have started submitting?

The other question is what do (or will) the students actually see. I don’t believe there is actually an easy way for me to test this.

Let’s try making the change. Appears to be no problem with other assignments. I assume Moodle will warn of any horrible consequence? Famous last words? Logically there shouldn’t be a problem, but….

Change made, but there is no difference in the display. The option to select just the students in a particular group does not appear. Perhaps it can’t be changed once submissions have been made.

Concrete Lounge #2: No apparent way to filter assignments/students by groups

Group membership is stored independently of assignment submission in the Moodle database. It should be possible to offer a “Group filter” – perhaps even one dependent on the “grouping” – as a way to modify the viewing of all submissions.

Looks like I’ll have to do this manually.

Documentation at the wrong abstraction layer

Concrete Lounge #3: The local help documentation (like most help documentation) is written at the level of functionality. It describes the interface and what each interface element does. It isn’t organised at the level of “activity type” i.e. the level of the users.

i.e. I have a certain model of how I want to manage the submission, allocation, and marking of assignments. That’s what I know. That’s where I am. Documentation that started at this level by describing a list of different models of using assignment submission and then describing how to configure the Moodle assignment submission system to implement this model would be more useful (and much more difficult to write).

Better yet. Would be an assignment submission system that would present a list of different models, briefly explain each one, allow me to choose which I want, and then set up the system to fulfill that model.

i.e. the system actually fit what I wanted to do, rather than required me to engage in explorations how to figure out if and how I could translate the functionality of the system into what I wanted to do.

Sorry, but the tools we have available at the moment aren’t quite ready to help basketball players become better hockey players.

Update

As per the comment below I missed an option to flick. That’s done and I can see the groups and make use of those. So here’s what I did

  1. Allocate unsubmitted from campus X to the marker;

    Set filter to the tutorial group I need and filter for “unsubmitted”. This is so that if they submit, they will automatically appear on the marker’s list.

  2. Allocate submitted from campus X to the marker;
  3. Auto-allocate the remaining submitted to markers;

    Priority is given to those submitted.

  4. Drop the allocation for campus X marker

    Problem: the campus X marker was originally allocated 22 students to make. But one has dropped out. Meaning when I do an auto-allocate (simulation) he gets allocated another marker.

    I also have to make sure that the “student marker” has an allocation of 0.

  5. Do the auto-allocation again.

Now all I need do is to figure out how much advice the markers will need to download, mark and resubmit the their allocated assignments.

What advice is there?

Hard to explore this myself as I don’t know how much my view of the system is the same as what a marker would see.

The “Download all submissions” option gets them all, not just the ones I’ve allocated.

Appears that the “view all”, play with filters, and then download is the way to go. I assume that the markers won’t need have the “Marker filter” to play with.

I wonder if the organisation has given any advice specific to markers. Of course, the “portal” I can access links to various staff support sites won’t let me login on my current browser. Nor on chrome.

Oh dear, the “portal” still has a large explicit link to the old assignment submission system.

Now begins the traipsing through various sites to figure out where it is.

A couple of red herrings and finally found the document I had been using (not only was it hidden away in the object repository, I had to login again to access it) and it confirms my suspicion. Downloading will be fairly simple for markers – once they find the right place and buttons to push.

But there doesn’t appear to be any specific file/resource that can be sent to markers. It appears that I’ll have to create my own (just like every other person in charge of a course with multiple markers). Of course, the other option is that I’ve missed the presence of this other document entirely.

It appears a cut down version of the larger document was circulated. Found this out via personal networks and Twitter, rather than via other means. The smaller document had been circulated earlier via email, but finding it in my Inbox……

The documentation is very generic. I’ll update it and include a direct link to the specific assignment.

What is downloaded?

A zip file with all student submissions in a single directory. Wonder how it works if the students are submitting multiple files? Does it put each student’s submission into separate directories then?

Specifying moderation samples

In terms of moderation, my practice is to specify to the marker at least 3 assignments that they should mark first. These are sent back to me ASAP for moderation and any advice on marking. The aim is that the 3 assignment represent a spectrum of abilities based on GPA typically: a 6+ GPA, a high 4/5 GPA, and a sub 4 GPA.

As in the past, this information isn’t part of the OASM system. So I have to do it manually via a spreadsheet. However, in the past the OASM system did provide a spreadsheet of students allocated to a marker. This enable the use of Excel formulas to find some samples. Doesn’t appear possible to do this via Moodle.

Luckily the “more student details” popup described here lets me click on a link in the list of students and find out the students GPA (amongst other things).

Concrete lounge: Can’t easily allocate sample marking based on student GPA (or other means) in part because can’t see how to expert students allocated to a marker to a spreadsheet.

Contacting the non-submits

Another task at this time is to approach the students who have yet to submit the assignment and see what’s going on. Some of these will have extensions, some won’t. Is there an option to show those students who have not submitted, but haven’t received extensions?

Doesn’t appear to be.

Concrete lounge: Can’t see how to list those students who have not yet submitted the assignment, but who haven’t been granted an extension.

The options appear to be scrolling through the list of almost 50 students and manually identifying those without extensions. But even when I do that, what can I do? Can I send those students an email message?

Doesn’t appear to be possible.

Concrete lounge: Unable to send group (or personalised) emails to students who have not yet submitted the assignment.

Wouldn’t be too hard to write a Greasemonkey script that extracts the email addresses of the students without extensions.

  • name in c2 (cell 2)
  • email address is in C4
  • an extension is indicated by a div with class extensiondate in c5

But that would require a bit of extra work. I do have some Perl scripts that I use for web scraping that could be more easily converted, but not as shareable. Script written and email sent.

Concrete lounge: Unable to use filters to identify students who have not submitted the assignment AND do not have an extension

Uploading results and marked files

Uploading the marked files seems fairly straight forward, as long as the same filenames are retained.

Question remains about how to upload the marks. The OASM system won’t be smart enough to extract the results from the uploaded files.

Oh dear, it appears that results need to be added manually for each student. That’s a bugger if you’re a casual marker employed to make 50 assignments. Beyond the time and workload implications, there’s the problem of human error, especially with a hugely repetitive manual process.

Correction, I need to enable the “offline grading worksheet” option. Yep, that adds “download grading worksheet” (and upload) to the options.