Assembling the heterogeneous elements for (digital) learning

Category: moodle Page 1 of 3

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?

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.

How to help improve the Moodle book module

As mentioned in the last post there are limitations in the Moodle book module that are acting as a concrete lounge. The following documents an attempt to help improve the module.

In the end, I’ve made some serious steps to contributing a bit of code to a standard plugin (as I write this, I’m imagining how experienced Moodle folk will shudder at the many misuses of Moodle terms in the following).

Update: The “bug” in the Book module reported below is not a bug. There’s actually functionality in the Book module to support this, it’s just not obvious. More explanation is available.

Task and context

As described in the last post the context is a course website hosted in the Moodle LMS. A course that uses quite heavily the Moodle book module. The module has import function that is meant to allow you to import a collection of HTML documents into a book.

Concrete lounge

The problems with the import process include

  1. Titles for imported titles are 100% from the HTML filenames.
    e.g. call your file “Diigo tool disappears_sub.html” and the chapter title will be “Diigo tool disappears_sub.html”. Rather than “Diigo tool disappears”.
    The _sub is required by the import function to indicate a sub-chapter. The .html is to indicate a HTML file.
  2. The order of imported chapters is based on the order in the file system.
    e.g. If I have the following files to import
    [code lang=”sh”]
    dj:001 david$ ls *.html
    A blog.html
    Diigo tool disappears_sub.html
    Diigo.html
    The tools we’ll be using.html
    Twitter.html
    [/code]
    Regardless of the order in which I add these files to the zip file (import is via a zip file), the order that they will appear as chapters in the book is dependent on the order the file system of the Moodle computer creates.
    Even if I create the zip file in the right order
    [code lang=”sh”]
    dj:001 david$ unzip -t import.zip
    Archive: import.zip
    testing: The tools we’ll be using.html OK
    testing: Diigo.html OK
    testing: Diigo tool disappears_sub.html OK
    testing: A blog.html OK
    testing: Twitter.html OK
    No errors detected in compressed data of import.zip.
    [/code]
    The first chapter will be “A blog.html”
  3. There is not option to remove all existing chapters before import.
    There are situations where I’m trying to replace the entire book with the import. Currently I have to create a brand-new book resource, or manually remove all the chapters in the current book.
  4. No method for linking to a chapter prior to import.
    If I create the collection of chapters elsewhere, there will be times when I wish to create links between those chapters. Currently there is apparently no capacity to do this.

Bricolage

Here’s what I’ve done so far to address this problem with the resources available.

Process to make changes to Moodle core

This seems to be the process I need to follow for the above which translates into

  1. Is there a tracker issue?
    Via various trails I end up at the book page/section in tracker. Raising the question which versions of the book Module am I dealing with?
    Time to track through the book issues in tracker. Those related appear to be

    • support for re-importing chapters
      Close to what I’m working on. But it’s old. Created in 2008.
    • Book HTML zip incorrect URL
      Picks up on the issue with links between chapters that have been imported. This appears to have been fixed and should be in from 2.5 onwards. Need to check this (NOTE: I haven’t actually tried this process yet).

    Nothing apparent.

    So as a user I can report the bug/make a feature request and then contribute by making a fix. So let’s create an issue in tracker. What type of issue should it be?

    • bug – A problem which impairs or prevents the functions of the product.
    • improvement – An improvement or enhancement to an existing feature or task.

    Either could apply. I’ll be positive and call it an improvement. Issue created.

  2. Which branches should the fix be made on?
    The advice is

    Bugs should normally be fixed on all the supported stable branches that are affected. New features should just go into master, but sometimes minor enhancements are made on the most recent stable branch.

    So where does this fit? I assume a bug or minor enhancement. The other factor is that if I make this change on the version that my institution is using, that will increase the chances that I might get to use it this semester (which are very slim). Of course, it’s difficult to remember/discover which version of Moodle we’re using. I think perhaps 2.7 for now. Which seems to the other supported release.

  3. Develop the change using git
    Prior work contains an example of how to get a version of the Moodle source using git and start making changes. Will start with that.

    My issue number is MDL-49128

    The process I’ll use is

    • Fork the branch of Moodle I want to work on MOODLE_??_STABLE
      [code lang=”sh”]
      dj: david$ history | grep git
      git clone git://git.moodle.org/moodle.git
      git clone git://github.com/djplaner/moodle.git
      git branch -a # what are the available branches
      git remote add upstream git://git.moodle.org/moodle.git # connect upstream
      git checkout MOODLE_27_STABLE
      [/code]
    • Create the branch
      [code lang=”sh”]
      git checkout -b MDL-49128-book-import-fixes origin/master
      [/code]
    • Make changes – see below
    • Testing process
      • zipfiles.zip
        Has the following files that should be displayed in this order

        1. The tools we’ll be using.html
        2. Diigo.html
        3. Diigo tool disappears_sub.html (this is a sub chapter)
        4. A blog.html
        5. Twitter.html

        Without either fix the chapters will start with A blog.html, Diigo.html etc. through to Twitter.html.
        With the both fixes, the order of chapters should match the numbered list above. Also, the chapter names should not include .html or _sub

      • zipdirs.zip
        Has essentially the same chapters, however, they are implemented as folders containing a single HTML.
    • Commit the changes to my repo
      This wasn’t as straight forward as I thought. Ended up with
      [code lang=”sh”]
      git remote set-url origin https://github.com/djplaner/moodle.git
      git push origin MDL-49128-book-import-fixes
      [/code]
      Which ends up creating this nice little summary on github.
    • Ask the Moodle devleopers to review it
      Updated the issue in the tracker, time to wait and see what I got wrong.

Making changes

I’ve been using the zipfiles approach. A zip file with a collection of HTML files, each file equals one chapter. This is fixed based on previous work.

There is also a zipfolders approach. A zip file of folders. Where each folder equals one chapter.

The order fix is working on zip folders. However, with the chapter names, I’m now getting both the chapter name and the file name. So The tools well be using/The tools well be using. Should the filename or the folder name be used?

I’m assuming the folder name. The book module import code appears to support this. For example when reading HTML files it is looking for default files in the folders. i.e. Default.htm and index.htm. Suggesting that it isn’t assuming that these have the names of the chapters.

That appears to be working.

Factors

I have to think that anyone who had used the import function in action – like I tried to do – would have been aware of the limitations of the import function. It just doesn’t seem designed to be useful. Thus it seems logical to suspect that maybe the original designer wasn’t a user. They weren’t solving their own (or someone close to them) problem. Just implementing a feature. Hence they weren’t in a position to know how limited it was.

This distance between implementing the function and using the function seems to be a common feature of concrete lounges. Anyone who has to use a concrete lounge for any length of time is going to be aware of the pain and want to change it.

The fact that this particular bit of pain has stood for so long, has to say something. Perhaps it’s just at the book module is just an unloved child? But it is part of Moodle core now, so it has to be perceived to be useful for some.

Kludging an authoring process with Moodle books (almost)

The following outlines an attempt to evolve the authoring “process” I currently use with Moodle books into something a little more useful. It won’t be the be all and end all of authoring process, just enough to solve the immediate problem I have. i.e. bricolage

I’ve essentially got this working on my end. The problem is that the Moodle book module has a few flaws in how its import function works which means I can’t really use this approach. At least until the book module is fixed. I’ve fixed most of it on my own install of Moodle. Will have to find out how that might happen.

Some related work

As it happens @abelardopardo wrote a post yesterday titled Re-visiting authoring: Reauthoring that touches on the broader problem and offers a solution. Many of the conditions he outlines align with mine, however, my need is more immediate and contextual than what would be need to explore and adopt his solution.

And I remember @timklapdor doing some work around this broader issue last year. Yep, I even commented on his post. A comment that captures some of my disquiet about institutional approaches to solving the authoring problem (I know my institution will be having another go at this soon).

Meaning I’m not trying to solve it at the institutional level. I’m simply aiming to enhance my current practice a bit. An “inside out” approach, rather than outside in.

A better idea

If I had the time I might have modified the approach below so that rather than exporting the Moodle book into HTML files on my computer, I’d have it exporting to pages on my smallest federated wiki (SFW) (and back into the Moodle book). With this approach the SFW version would be the definitive version. It has version control built in at the paragraph level and opens up a range of possibilities of students (and others) being able to fork and work on their own versions of the content. An affordance that could potentially be much more interesting from a learning perspective and in terms of being “open”.

However, the SFW authoring environment doesn’t feel quite as natural to what I plan to use below. That may simply be familiarity, but there’s also the problem that SFW somewhat denigrates the use of HTML and is somewhat limited in terms of presentation and embedding. Why not use SFW, rather than Moodle books? Mainly because the course design currently (and perhaps problematically) relies on Moodle activity completion. Not a function that is available in SFW, nor a function that is sensible in the SFW world-view. It also appears – after a quick test – that SFW doesn’t necessarily play all that nicely with search engines. Meaning that SFW doesn’t solve my big bug bear with Moodle, no search capability.

Deja vu all over again: why?

I do this with some reservation due to a sense of deja vu. Almost 20 years ago as I prepared my first totally web-based course I wrote a set of scripts to help with authoring the web-based study material (thank you the web archive). Tools and an outcome not unlike the approach I’m working toward below and not that far removed (but far more primitive) than those mentioned above.

Why? Why after 20 years this authoring problem still hasn’t been solved? Why do there remain a plethora of disjointed systems and no-one really good solution?

Perhaps mainly because there is a plethora of disjointed systems in which the resources that are authored have to fit. Each of those disjointed systems have different world-views and subsequently sets of functionality. Hence it’s almost impossible for one authoring process to fit nicely into all of them. e.g. the talk above about integrating SFW and Moodle books. Adding more complexity, and touching on the comment I made on @timklapdor’s post, the people who are likely to use, the people that will use these authoring systems come with their own set of world-views, preferences and peccadilloes. The gaps between all these world-views are perhaps just big enough to prevent the wide acceptance of a single approach.

Suggesting that designing or selecting a single system (an outside-in approach) for everyone to use is destined to fail. There will always be gaps between the different world-views. Even if you can get everyone to agree, in a year or so another type of system will arise and there will be another gap to overcome. Perhaps a better approach is focus on what people are currently doing and bridge the gaps (an inside-out approach), which is sort of what I’m doing here.

The problem and context

As outlined in a previous post and shown in the following screenshot my course uses “Moodle books”. Each Moodle book tends to be focused on a specific task and generally is wrapped around external resources.

Week1

These books were originally written in HTML using the vi editor and manually imported into Moodle. Last year I made ad hoc changes by using the book module’s “editing” interface. That’s not a great process.

The wish list for what I want from a process

  1. Have an authoritative source HTML file that contains all the content for the book.
  2. Use directories and files to create a structure that mirrors the learning paths on Moodle.
  3. Perhaps in way that allows the content to be put on another website so it can be searched.
  4. Have that structure under source control.
  5. Allow simple updating of the Moodle book.
  6. Benefit from the Moodle migration smarts.
    The Moodle books point to additional Moodle activities (e.g. quizzes, discussion forums) etc that are used in learning activities in the books. When a new offering of the course is prepared, the old offering is migrated. This migration process is smart enough to have the books in the new offering pointing to the activities that belong to the new offering. The “books” in source control wouldn’t be automatically updated this way.

In essence, I’d like to edit the books using vi (or whatever HTML editor etc I end up using) on my local computer. When I’m happy with the book, commit it to source control and import it into Moodle.

In a perfect world, at the start of a new term I’d have a process that dumps the migrated books from the new course site onto my local computer ready for editing and importing into source control.

Exploration and Development

The following documents some exploration of various possibilities that might help achieve the above.

Import and export from a Moodle book

When I started all this either I was aware of, or the Moodle books didn’t have an import facility. Time to play with that as it may be the foundation for putting content back into Moodle quickly.

It appears it accepts each chapter as a HTML file. Which is a bit of a bugger as I’d hoped to work with a single HTML file locally and upload that. Appears I may need some sort of script to produce the format required by the Moodle book. Let’s test this out

  1. Download an existing book.

    I’m doing this by using the “print book” function. This produces a fairly bare HTML file of the entire book that forms the basis for the local copy.

  2. Look at the HTML.
    Diigo/Firefox has stuck a bunch of css etc into it. Remove that.

    • book_summary/title
      classes book_summary and book_info use for entire book information.
    • class book_toc_numbered
    • Chapters are surrounded by a div with class book_chapter, heading 2 used for the title.
    • Sadly sub_chapters also appear to use class book_chapter but with heading 3
    • A collection text/css files are created when saving the printed file.
  3. Import that single HTML file into another book.
    Well that doesn’t work. Apparently an invalid file type. Let’s try removing all the diigo etc crud. Nope that doesn’t help.
    So what about a single section of HTML?
    Of course, it has to be a zip file that you upload. Idiot. So zip file with two html files. One the big HTML from the book itself, and the second a small excerpt.
    So it does the import and presents some feedback – “Importing” “Relinking” and then a continue button.

    Appears to be a very simple import. Each HTML is create as a single chapter. Sequenced in the order found in the zip file.

    What if I import again, but change one of the files to end in _sub.html. This is meant to create a sub chapter. That works as expected. Another two chapters added to the book, exactly the same as the other two. But the test_sub.html has been created as a sub-chapter. i.e. the title of the chapter is taken from the title, but it isn’t smart enough to remove the _sub, even though it knows what _sub at the end indicates. Note: I really should do something about that, looks like it would only take the addition of a single line of code.

  4. Look at the content and develop the script.
    Looks like the script will need to parse the HTML “print” version from the book by

    • Extract all the div class book_chapter
    • for all of those (in order that they are found in the HTML file)
      • create a new file with the following name format NUMBER TITLE{_sub}.html
        1. NUMBER – A number such as 001 to ensure that the order stays the same.
        2. TITLE – the title from the heading 2 or three immediately inside the div.
        3. _sub – if it’s a heading 3 – indicating a sub-chapter.
      • Add in the content of the div into that.

    Also appears like I’ll need to have two separate functions, related to preparing the version of the file to

    1. edit; and
      This would be a single HTML file that I use to edit.
    2. import.
      The one outlined above that would imported into Moodle.

    So which Perl HTML parsing module to use? TreeBuilder::XPath was the most recent I’ve used. But I’m doing jquery a bit recently, so Mojo::DOM is interesting.

    Yep that worked. Script is now producing an EDIT.html file that I’ll use to make changes.

  5. Import the broken up HTML files into another book
    The aim here is to

    1. extract all the book sections from the EDIT.html file
    2. create a collection of separate HTML files containing the contents of each book section
    3. zip up all those separate HTML files ready for importation
    4. remove the files

    Done. Fairly simply. Tried import into the book and it’s sort of worked. The problems to solve are

    1. The inclusion of “.html” in the chapter name.
    2. The inclusion of “_sub” in the chapter name.
      These first two problems appear to be down to how the Moodle book import function works. i.e. it doesn’t remove these, which is somewhat surprising. Have made some initial changes to my local Moodle installation (about line 83 of mod/book/tool/importhtml/locallib.php), but which won’t work on all uses of the module – e.g sub-directories, HTML files with .htm extensions etc.
      [code lang=”php”]
      # DJ’s changes
      if ( preg_match( "/.html$/", $chapter->title ) ) {
      $chapter->title = preg_replace( "/.html$/", "", $chapter->title );
      } # end DJ’s changes

      if (preg_match(‘/_sub(/|.htm)/i’, $chapter->importsrc)) { // If filename or directory ends with *_sub treat as subchapters
      # DJ’s changes
      // remove _sub from title, should be last given above replacement
      if ( preg_match( "/_sub$/", $chapter->title ) ) {
      $chapter->title = preg_replace( "/_sub$/", "", $chapter->title );
      } # end DJ’s changes
      [/code]

    3. The inclusion of #39; (i.e. html entities) in the chapter name.
      This appears to be due to the process I’m using to save and process the exported book files. I need to modify it to decode HTML entities. Easy enough in Perl using HTML::Entities. But I also have to update the heading back in the HTML. Done.
    4. Chapters having no content.
      My immediate guess is that the HTML files being imported still have some of the Moodle book divs etc and that this is clashing. So remove those and test. Nope, that didn’t work. Time to look at the code
      [code lang=”php”]
      if (preg_match(‘/<body[^>]*>(.+)</body>/is’, $html, $matches)) {
      return $matches[1];
      [/code]
      Oh dear, regular expression matching. That’s the problem. It requires a body tag around the outside. Have to love open source projects where you can look at the code. That’s fixed.
    5. Duplicate headings.
      The import file needs to have the heading title and the other book chapter remnants removed to prevent issues. Done.
    6. The chapter numbers still present.
      The Moodle book import processes the collection of files in the order it sees them in the zip file. To make sure that the order is what I want, the filenames start with numbers. The problem is that the import process doesn’t remove the numbers, so you end up with stuff like 2 2 Diigo where the first 2 is from the Moodle book module and the 2nd 2 is from the file name.
      I can’t change the Moodle book module code quickly enough to help me.
      Can’t remove the numbers in my export script as this would change the order of the files imported.
      Leaving exploring the zip function to see if I can specify the order the files should be zipped in the script, without relying on numbers in the file system. Can do this with zip, however, the book module doesn’t play nicely. It looks like it just unzips the file, forgets about any order in the zip file and relies on the order from the file system.
  6. Additional problems
    Of course it’s not going to be as simple as this. A major problem will be that via this process I will lose the capability to correctly link between pages in a book. The import process back into the Moodle book will either actively change links to a Moodle book, or it will ignore them.
    It will also play silly buggers with links to/from other Moodle books. i.e. modifying a book this way will break all other links to the original version of the book.

    Some possible solutions

    1. Have the import script look for and announce links to Moodle books.
      Thereby allowing for manual intervention.
    2. Run the institutional “check course” function to check for broken links
    3. Modify the book module so that the import function supports some sort of variable for pages.
      i.e. the ability to use {TITLE_OF_PAGE} as a link to a page within the current book. Where TITLE_OF_PAGE is the chapter title.

Export all Moodle books

This will have to wait until another day.

A structure that works

Looks like being something like

  • Week folder
    • Book folder
      • ALL.html – the version imported from Moodle.
      • EDIT.html – output of “parseBook.pl ALL.html” ready to edit.
      • IMPORT.zip – output of parseBook.pl. A zip file ready to import into Moodle that contains ALL.html split up into the appropriate separate HTML files.

git{hub}

Wait for another day. But I assume the aim would be to have EDIT.html in git with the surrounding structure.

Planned process

  1. Create a folder for each week.
  2. In that create a folder for each book using 001 etc to get order correct
  3. Save a HTML version of the book from Moodle into EXPORT.html in that directory
  4. Run the script which will produce an EDIT.html file in that directory
  5. Make the changes in the EDIT.html file
  6. The EDIT.html file can be kept in github?
  7. Run the script to produce the import version.

To do

  • Look into how to suggest/contribute the following changes to the Moodle book
    • Modify the chapter titles imported to remove the _sub and the .html.
      Semi-done.
    • Import chapters in the order they are contained in the zip file (if possible)
      The zip stuff is done by lib/filestorage/zip_packer.php. ATM, the book module is simply extracting files to storage. Hence the problem with out of order. zip_packer does have a list_files method that might just provide the list of in order file names that we’re after. This actually works and the book module does use this initially to get the filenames. But it loses the order when it creates a hash with the pathName as the key.

      That’s fixed.

    • Have an option to remove all existing chapters prior to import.
  • Think about the implications of integrating SFW .

A #moodle course site wide "macro" facility?

UPDATE (Feb 2015): Have implemented a version of this using a simple Javascript approach. Not quite course site wide, but functional

In the process – like an increasing number of Oz academics – updating a course site for a new semester. I’m fairly happy with the site as it stands and the Moodle copy process does a good job of updating links (i.e. the link to assignment 1 now links to assignment in the new course site, not the old). The trouble is that the current process doesn’t currently do a good job with dates and other values that may change from semester to semester.

So I’m wondering

  1. How one might implement a course site wide macro facility?
  2. Alternatively, what existing feature of Moodle am I unaware of?

The problem

Throughout the course site there are a range of labels that will exist each semester, but which may have slightly different values. Some examples include:

  • Due dates for assessment.

    Assignment 1 tends to be due at the start of week 5, but week 5 has a different date each semester.

  • Weekly titles.

    The course is structured by week. Each week has a particular question as its title. I like to tweak these titles based on what works (or doesn’t).

Since these “labels” are used in multiple places in the course site, if the values of these labels have to change, I have to find all uses of these labels and change them manually.

One solution type – a macro facility?

I’d find it useful if there was a central macro facility where I could define a range of variables and their values. For example

  • ASSIGNMENT_1_DUE_DATE = 31st March – start of week 5
  • WEEK_10_TITLE = “Digital citizenship”

On the course site, I would then use the variable (WEEK_10_TITLE), rather than the value. Some technology would replace the variable with the value prior to display to the user.

Implementation?

Really thinking aloud here.

Given the cost of changing the Moodle core – I assume putting something like this in Moodle would require a change to core – that’s probably not an option in the short-term. But this is also where existing discussion of an idea like this may have occurred or been addressed.

The only potential method by which I could implement something like this that springs to mind is Javascript. i.e. include some javascript in all the Moodle course pages that implement some form of macro substitution on the client’s end.

Post script

This is an example of attempting to live within the constraints of the system. A longer term solution would be to break out of it entirely. Give up the question of fixed weeks, fixed due dates for assignments, the idea of a course remaining so consistent that only a few values need to change each semester etc. On the last point, there will be more detailed changes made. A feature like this simply gives more time to make those “better” changes by saving time on the more menial requirements.

I also think it’s an interesting example of how institutions that are increasingly moving to standardised, industrialised, approaches to supporting learning & teaching are doing it in ways that they are either unaware of gaps in their systems/processes or are unable to conceptualise how this might work.

TAM, #moodle, online assignment submission and strategic implementation

The following is an attempt to expand upon a mention in the last post about exploring one set of thoughts about why/how we might extend/reuse/build upon some prior research using TAM (Technology Acceptance Model) and its application to understanding the use (or not) of Online Assignment Submission and Management (OASM) in higher education.

In summary,

  1. In 2005, we published a couple of papers (Behrens et al, 2005; Jones et al, 2005) in which the Technology Acceptance Model (TAM) (Davis, 1989; Venkatesh et al, 2003; Venkatesh & Bala, 2008) was used to explore why an increasingly widely used online assignment submission and management tool (OASIS) was successful.
  2. In 2009/2010, that system was replaced as part of an project to adopt a single LMS (Moodle) that was designed to provide “appropriate support for staff and students to access and use ICT effectively in learning and teaching” (Tickle et al, 2009, p. 1040)
  3. There have been mixed messages about the success of that project. For example, Tynan et al (2009) suggest this

    It is probable that since the institution had undergone a large review and renewal of technology in the learning management system where processes to support academics were put in place and where academics were included in decision making and empowered to change and upskill, negative attitudes towards the general impact of technology were not an issue for staff. One can hypothesise that these issues were principally resolved.

    . While Rossi and Luck (2011) report on a range of issues with the transition including a significant loss of functionality in terms of online assignment submission and management.

    There have also been some significant anecdotal comments about issues with the Moodle OASM functionality with large classes.

  4. It’s now 3/4 years since the implementation of Moodle. Now would appear to be a good time to explore the usage of the Moodle OASM functionality and the perceptions of the teaching staff. This would enable some comparison with the earlier findings from the 2005 work. Especially given findings from this work

    The study concludes that staff perceptions have indeed changed and whilst more staff are using online systems for assignment submission, marking and feedback, many do not have a positive attitude towards it. This could be explained by the increased prevalence of available systems and tools alongside their mandated presence.

    but at the same time “but students wholeheartedly in support” of OASM.

There’s a bunch of stuff to unpack here, an initial start includes

  • The original OASM system was entirely optional. There was no perception that OASM was compulsory or mandatory in the early noughties. As Huber (2013) suggests there is a growing trend toward the expectation or the explicit mandating of OASM. TAM research suggests that optional and mandatory adoption decisions have different impacts/factors.

    Is OASM now seen as mandatory?

  • What is the actual use of OASM?

    We can use “learning analytics” to examine the trends in adoption and use. We did this in 2009 (Beer et al, 2009). The image below (click on it to see it larger) compares the use of “evaluating students” features between the institution’s prior LMSes: Blackboard and Webfuse. “Evaluating students” includes both OASM and quizzes. The purple and green lines indicate the max/min adoption rates expected for this feature from Malikowski et al (2007).

  • The impact of prior use.

    As Huber (2013) suggests OASM is increasingly more widespread. Obviously, prior experience with OASM will influence perceptions (versions of TAM suggest this as well). But will there be a difference between people who have used the Webfuse OASM system and those who have used other systems?

  • What are the factors that impact perceptions.

    The free text responses we focused on in earlier papers are useful for identifying what it is that people like (or don’t) about these systems. This could be interesting.

  • How specific do we get?

    Huber (2013) draws on surveys that are much more explicit in exploring different uses of OASM. The TAM survey is more generic and open ended. What’s the right mix?

Blogs, learning analytics, IRAC and BIM

In 2014 I am hoping to make some changes to BIM that will enhance the course I’ll be teaching. The hope is to leverage various learning analytics to enhance student learning. The following is an attempt to use the IRAC framework to think about what might be done. Essentially a bit of brainstorming about possible future development.

Each of the headings below link to the IRAC framework. First off the content and the purpose of this use of learning analytics is described. Then each of the four components of the IRAC framework – Information, Representation, Affordances and Change – are considered.

I’ve just learnt about the proceedings from the 3rd Workshop on Awareness and Reflection in Technology-Enhanced Learning, will need to read through that content for any additional insights.

Context

The course is a 3rd year course in a Bachelor of Education. It’s taken by folk hoping to become teachers at every level from prep, through Grade 12 and into the VET sector. The focus is the students be able to use Information and Communication Technologies to enhance/transform the learning of their students. During the course the students complete a three week practical in a school setting. The course is offered twice a year. The first offering has average around 300 students spread over three campuses and online. The second offering averages around 100 students all online. The students in the course are not necessarily all that ICT literate.

The students are required to maintain an individual blog that they use as a learning journal. The learning journal is intended to be used for capturing experiences, feelings and reflections. Contributions to the learning journal contribute 15% of the final mark. There is no formal marking of blog posts. Marking is done on the basis of the number of posts per week, the average word count, and the number of links to both external resources and blog posts from other students.

2013 was the first year the learning journal assessment was used. All 2013 student blog posts are archived in two instances of BIM. The plan is to use learning analytics to explore this data and test out various approaches that could be integrated into BIM and the course’s operation in 2014.

Purpose

At a high level, improve student learning while keeping the staff workload appropriate. Briefly, the pedagogy in the course is trying to encourage students’ self-regulation, reflection and building a PLN/making connections. I want the students to take ownership of their learning around ICTs and Pedagogy and for them to create and share a range of artefacts, insights and perhaps knowledge. The purpose that learning analytics can play in this is helping both the students achieve this and help the teaching staff support this.

Some high level aims for harnessing learning analytics.

  1. Provide students with some idea of how they are going and perhaps more importantly how to improve.
  2. Increase the diversity, quantity and quality of the connections between students and their posts and blogs.
  3. Allow teaching staff to identify who is struggling, who is doing well and who is in between and then help support staff in engaging appropriately.

A quick skim of 2013 course evaluation responses reveal some comments (emphasis added) from the semester 1 offering

The blog is a good idea to ensure the students are trying new ICTs during the course however the assessment was pointless. There was no real reason for us to be writing a certain amount of blogs per week. I found it a nuisance to maintain (on-campus student)

Probably the blogging was unnecessary but I still didn’t mind that. (on-campus student)

The blogs were very time consuming – and considering they were marked without being reviewed/marked then I am concerned that we could have done what ever we wanted! (on-campus student)

I also found blogging to be very beneficial in building my PLN (online student – most effective aspects of the course)

being forced to blog was actually great as it brought online students together as we shared resources and got to know each other. (online student – most effective aspects of the course)

the blog we had to keep, it had no purpose to it (online student – least effective aspect of the course)

the amount of blogs expected (online student – least effective aspect of the course)

The blogging, although I can see why we had to do it, I found it was hard to keep to the time frames as an online student (online student – least effective aspect of the course)

I don’t believe that I gained from blogging 3 times per week. I would rather have been assess on the quality of 1 blog per week and professional feedback that I could have provided to another student (rather than just links in the 3 blogs) (online student – least effective aspect of the course)

There were other comments on the blogs, common themes so far seem to be

  • The purpose of the blogs was non-existent to some, especially given that they weren’t marked based on quality by a human.
  • Blogs were potentially seen as more problematic in Semester 1 because of other issues with the course.

Change

Change is actually the last part of the IRAC acronym, but I’ll put it first. Mainly because it is the IRAC components that is least considered in learning analytics related projects (IMHO) and the one that I think is the most important.

In this case, I can see there needing to be three types of change considered: going outside of Moodle, using features inside of Moodle, and insidie BIM.

Outside Moodle

In short, thinking about, designing and implementing the type of changes to BIM and pedagogy outlined below is inherently a learning experience. I’m not smart enough to predict what is going to happen prior to implementation. I always gain insight when engaged in these activities that I want to leverage straight way into new approaches and new technological capabilities. i.e. I want to be able to make changes to BIM during the semester.

Not something I can do with the standard processes used for supporting a Universities institutional LMS. Hence the need to look at how I can do changes to BIM outside of Moodle and the institutional installation. In 2013, I did this via a kludge, essentially some Perl scripts and a version of Moodle/BIM running on my laptop.

Beyond the constraints of the institutional LMS processes, there’s the question of information and resources other than what is typically available to a Moodle module. Some examples include

  • Activity completion.

    Currently a small part of the 15% for the learning journal assessment in this course is based on students completing the activities for set weeks. This is in Moodle, but a module like BIM will typically not be able/expected to access this information.

    QUESTION: Can/how a module access information from other parts of a Moodle course site?

  • Student demographic and academic data.

    e.g. GPA of a student, how many times they’ve taken the course, might be used to help identify those at risk. Typically not information in Moodle.

  • Student dispositions.

    Data about students dispositions and self-regulation may be useful (see below) in providing advice. This would have to be gathered via surveys and would not be normally in Moodle.

  • Computationally heavy analytics.

    It is likely that a range of natural language processing and other potentially computationally heavy algorithms could be used to analyse student posts. Most enterprise IT folk are not going to want to run these algorithms on the same server as the institutional LMS.

All of this combined, means I’ll likely explore the use of LTI mentioned in this post from earlier in the year. i.e. use LTI to enable the version of BIM used in the course to be hosted on another server. A server only used for BIM in this course so that change can happen more rapidly.

In addition, that other server is also likely to run a range of other software for the computationally heavy analytics – rather than try and shoe-horn it into a Moodle module.

Inside Moodle

There’s a line of though – with which I agree – that learning analytics are most useful when supporting a specific learning design. The more specific, the more useful. This is in tension with the tendency of LMS tools to being generic. For example, much of what I’m talking about here moves BIM away from it’s original pedagogy of students answering questions to be marked by markers toward a more connectivist approach. Becoming more specific may limit the people who can use BIM. Not a big worry at the moment, but a consideration.

Moodle 2.0 has evolved somewhat in its ability to support change. For example, the introduction of renderers separates out the representation of BIM from the data and allows different themes to override a rendered. In theory, allowing other people to modify what is shown. However, the connection with a theme is potentially a bit limiting.

Task: Explore the concept of renderers more often.

Inside BIM

There is much that could be done to the structure of BIM to enable and support rapid development. e.g. Moodle is now supporting unit tests, BIM needs to move toward supporting this.

Information

To scaffold this look at the information that could be drawn upon, I’ll use the DAI acronym. i.e. the information to be used in learning analytics can be listed as

  • Data – raw data that is the starting point (e.g. blog posts for BIM).
  • Analysis – what method/algorithm is going to be used to analyse and transform the source information into….
  • Insight or perhaps Information – something that potentially reveals something new (e.g. how good is the reflection in this blog post)

Source

Information we currently have access to

  • All student blog posts from 2013.

    As part of the BIM database tables in the Moodle database.

  • The date and time when posts were made.
  • Student performance on assignments and in the course.

    Currently in a database in another non-Moodle assignment submission system. Pondering if this needs to move to the Moodle assignment submission system and thus the Moodle gradebook. But which raises a question..

    Question: Can/how would a module like BIM get access to Moodle gradebook data in the same course?

  • Some student demographic data.

    Currently as a CSV file manually downloaded from Peoplesoft by someone else. Includes age, postcode, sector, GPA.

  • Course and institution related dates.

    e.g. assignment due dates, semester start and end dates etc.

Information that we don’t have access to, but which might be useful

  • Comments on student blog posts.

    There’s no really standard way between different blogging engines of tracking and archiving the comments made on blog posts. So we don’t record those. Anecdotal observations suggest that many of the “connections” between students occur as comments. EduFeedr did some work around this.

  • Student perceptions of the learning journal assessment.

    Might be some mention in the 2013 course evaluation results.

    TASK: Take a look at the 2013 course evaluation results and see what mention is made.

  • Student dispositions and mindsets – e.g. this work.

Analysis

A very limited list of possible forms of analysis on the information we currently have

  • Link and social network analysis etc.

    Who is linking to who? etc.

  • Natural language processing, computational linguistics etc – which might open up possibilites such as

Combining the above with student demographic information and dispositions could also reveal interesting correlations and relationships.

I need to become more aware of what possible forms of analysis might exist. At the same time, the list of affordances (see below) may also suggest forms of analysis that are required.

Representation

Early suggestions for representation might include

  • Social network diagrams of various types.

    For students and teachers to see the structure and evolution of the social network of posts/blogs. e.g. this EduFeedr scenario

  • “My progress”

    Allow students to see a collection of stats about their blog and to see it in connection with others.

  • Student posting

The work reported in this paper on using badges gives on possibility for representation and also in terms of affordances for students to compare what they’re doing with others.

Affordances

The actual definition of affordances in the IRAC framwork – like the IRAC framework itself – is still in the early days of refinement. Here I’m going to use affordances as functionality that BIM might provide. Obviously influenced by the purpose from above.

  • Help students find interesting and relevant posts from other students.
  • Help students find interesting and relevant external links.
  • Allow students to see how “good” their blog is.
  • Show students how their blog compares to other students.

    There are reservations about this.

  • Allow all participants to get some idea of the important topics being discussed each week and over other time periods.
  • Show staff a progress bar/heat map/visualisation of some sort of student progress against expected milestones/questions.

    The EduFeedr progress visualisation below (click on it to see it bigger) is an inspiration.

  • Help staff to intervene and track interventions with all students.
  • Support staff in creating auto-marking approaches.

EduFeedr Progress

Measuring impact and improvement

If we ever get around to doing something in 2014, how will we know what’s changed? Alternatively, what might be useful to learn about the use of the student blogs in 2013?

Some possibilities

  • When did student post?

    Students were expected to have a number of posts each week, however, it was only assessed over a 3 or 4 week period.

    • How many students posted consistently each week and how many did the mad dash toward the end of the 3 or 4 week period?
    • Was there any correlation between when posts were made and the content of the posts, the students performance in the course, their GPA or anything else?
  • How did (if at all) did student posts change over the semester?
    • Is it possible to tell when holidays, professional experience, other assignments were due etc. from the student posts?
    • Did the emotions in posts change over semester?

      The course is quite heavy going. Especially in the first few weeks. I would expect some great nashing of teeth in the early weeks and perhaps in the leadup to assessment.

    • How did the connections between posts/students change over the semester?
  • Is it possible to develop indicators that might identify certain types of students/posts?
    • Indicators to identify students who are about to drop out?
    • Indicators to identify popular posts?
    • Indicators of students at all levels?

      e.g. what does a “good” student write about that an “ok” student writes about?

  • What were the most mentioned concepts during the semester?

To do

Some tasks left to do include, in no particular order

  • 2013 blog posts
    • Do some analysis of the 2013 blog posts.
    • Test out some of the planned analytics on these posts.
  • BIM
    • Explore the transition to renderers.
    • Explore unit tests.
    • Explore the “Moodle way” for assignments, marking, rubrics, outcomes etc.
    • Develop the “automated” marking feature.
    • Explore how the select “analytics” features will be identified.
  • LTI
    • Identify a good external hosting service.
    • Confirm that an LTI version of BIM will work with the course.
  • Purpose
    • Clarify exactly what pedagogical aims are going to be valuable.
    • Explore the self-regulated learning literature.
    • Look at the course evaluation responses from 2013 and see if there’s anything important to address.
    • Eventually identify a specific set of outcomes I want to work toward.
  • Information
    • Explore the various analysis methods that could be useful.
    • Explore how the analysis is best done with BIM, Moodle and PHP.
  • Representation
    • Explore how/if badges might be a possibility? USQ Moodle version and capabilities.
    • What PHP support is there for visualising social network diagrams?
  • Affordances
    • Get more into the literature around affordances, especially any work people have done on how to design affordances for learning/teaching.

#moodle, blogs, Moodle blogs and #bim

BIM is a Moodle activity module that I developed and use. BIM evolved from an earlier system called Blog Aggregation Management (BAM). BIM’s acronym is BAM Into Moodle. As the name suggests, BIM is essentially a port of all of BAM’s functionality into Moodle. Both BAM and BIM are designed to help with the task of managing students in a course writing and reflecting on their own individual web blogs. In particular, it was designed to do this for courses with hundreds of students.

The aim of this post is to explore and explain a comment that often arises when BIM is first mentioned. i.e. doesn’t Moodle already offer blog integration? The following tweet from @tim_hunt is an example of this.

https://twitter.com/tim_hunt/status/397489330169458688

The aim here is to answer the question, “What does BIM offer that Moodle’s existing blog integration doesn’t already provide?”

In short,

  • Blogs in Moodle are focused at providing a way for authors to create a blog inside of a Moodle instance.
  • BIM is focused on supporting teaching staff in managing a course where all students are expected to write on their own externally hosted blog.

Blogs in Moodle

Each user in Moodle has their own blog. i.e. the user’s (student, teacher or other) blog resides in Moodle. The functionality used to create and edit blog posts is provided by Moodle.

Each user’s blog can have an RSS feed if configured (by default this is turned off). However, standard advice appears to be to have RSS feeds secured (i.e. only people who can login to Moodle can access the feed).

There is support for “course tags” which allow particular posts to be associated with a course. Posts associated with courses in this way are still visible elsewhere.

If the Moodle administrators have enabled it, users can register their external blog with their Moodle blog. For example, if I registered this blog with a Moodle blog, then anything I post to this blog would also appear in my Moodle blog. Posts from an external blog can be deleted from a Moodle blog, but can’t be edited.

Summary

Moodle’s blog functionality is focused on helping users create and maintain a blog that sits within a Moodle instance.

It is user-focused, not course-focused. e.g. it appears to offer no functionality for teaching staff to find out which students have blogged or haven’t, and no functionality to mark blog posts.

The problem here (at least for some) is that

Reflective learning journals are demanding and time-consuming for both students and staff (Thorpe, 2004, p. 339)

Blogs with BIM

BIM doesn’t provide any functionality for students or teachers to create a blog. Instead, BIM relies on the author creating a blog on their choice of blogging platform (e.g. I always recommend WordPress.com). This means that the students’ blogs (it’s almost always student blogs that BIM works with) are hosted external to the LMS. Each student’s blog is their individual blog.

What BIM does is

  • Make a copy of all the posts students make on their blog within the LMS just in case the dog eats it.
  • Provide a couple of aggregated views that shows you who has blogged, how much they’ve blogged and how recently they’ve blogged.
  • Allows different teaching staff to see these aggregated views for the students they are responsible for (while the “in charge” teacher can see all).
  • Shows which students haven’t registered their blogs yet and provides a mail merge facility to remind them to do it.
  • Provides an interface so students can check what BIM knows about their posts.
  • If you really want to, allows you to mark student posts.

    This is done by specifying a set of questions that student posts should respond to, and the provision of a marking and moderation interface. Finally, the marks will integrate into the Moodle gradebook.

Summary

BIM functionality is focused on managing (and marking) of student blog posts. It aims to reduce the time-consuming nature of reflective journals implemented using blogs.

What functionality BIM currently provides for this task remains essentially the same as was designed into BAM in 2007. I’m hoping 2014 will see some long overdue evolution in functionality.

Moodle blogs and BIM?

The Moodle blog functionality is all about helping authors produce blogs. BIM is currently all about helping teachers manage and mark the student use of blogs. It is possible to argue that neither do an overly fantastic job.

This means that it should be possible for the two to work together. i.e. a student could register their Moodle blog with BIM, rather than using WordPress or some other external service. Indeed it is. I’ve just successfully registered a Moodle user blog in BIM.

This is of potential interest in situations where what the students are reflecting on might raise privacy concerns (e.g. nursing students – or just about any other profession – reflecting on their placement experiences). In this situation, the students could create their blog within Moodle and register the RSS feed with BIM.

However, the privacy of this approach depends on the blog visibility settings within Moodle and their impact on the generation of the RSS file. There appear to be three relevant settings for “blog visiblity” in Moodle

  • “The world can read entries set to be world-accessible”
  • “All site users can see all blog entries”
  • “Users can only see their own blog”

The question is what effect this visibility setting will have on the RSS file required by BIM. i.e. If visibility is set at “Users can only see their own blog” will this stop generation of the RSS file? A quick test seems to suggest that the RSS file is still generated.

This begs another question about privacy. The “security” or “privacy” of the RSS file generated by a Moodle blog is an example of security through obscurity. i.e. if you know the URL for the RSS file, you can view. The “security” arises because the URL includes a long list of hexadecimal numbers that make it hard to guess.

References

Thorpe, K. (2004). Reflective learning journals : From concept to practice. Reflective practice: International and Multidisciplinary Perspectives, 5(3), 327–343.

Page 1 of 3

Powered by WordPress & Theme by Anders Norén

css.php