How hard is it to get a personalised class timetable?

Apparently, it is too complex to create a personalised class timetable for students at the institution I’m attending. I have previously described what I (as a student) have to currently do to create my class timetable as well as explaining that I helped implement a personalised class timetable system at the same institution about 10 years ago.

The purpose of this post is to find out just how difficult it would be to do it today.

The context

The institutional context includes:

  1. A collection of static web pages that contain class timetabling information.
  2. A newly introduced Google Apps for Education for students (i.e. students all have institutionally provided individual Google calendars).

The plan

The previous personalised timetable system at this institution was a stand-alone web application. With some input it created a one week summary timetable as a single HTML page. Given the change in context, in particular the availability of Google calendar, the plan is to respond to this change. Rather than having a stand-alone institutional application, the plan is to integrate with what students are using.

That is, the plan is

  1. Web scrape the institutional web page to get the data.
  2. Use the data to create an iCalendar file or similar with the timetable information.

The idea is that the student can then important the iCal file into Google Calendar or any other calendar program that supports that file format (which is most). If this were an institutional system, it might be able to automatically pre-populate all students’ individual Google calendars with their class timetable.

Missing access

The last time I implemented a system like this I was within the institution, this time I’m not. This means I don’t have access to information such as

  • The list of courses a student is enrolled in.
    For the test I’ll hard-code it with the four courses I’m enrolled in. Wouldn’t be hard to taken any list of courses and generate a calendar.
  • The dates for each week in the University calendar (e.g. week 1 is Feb ?? to Mar ??)
    I’ll also have to hard-code this.
  • Assessment due date information which could be added to the file.
    I’ll leave this data out of this little test.
  • Ability to automatically import information into the institutional Google calendar.
    Not sure if this is possible. If it were the institution could automatically insert into a student’s Google calendar their timetable.

Web scaping

I don’t think the web page format for the timetable has changed too much. Am hoping that I still have the code that can easily web scape the appropriate web pages.

Yep, there’s a bit of code from a couple of years ago, let’s see if that will work.

I think the hardest part here will be getting this ancient Perl code to run on my new computer when I haven’t done anything with it for years. Yep, get that working and hey presto it is extracting the information.

One of the limitations of the old Perl install is that the database stuff isn’t working. This is okay as I don’t need it for this little exercise. So, remove the database stuff and create a hashed data structure that allows manipulation.

Done.

Create an iCalendar file

Can this be done in Perl? Yes, a quick Google reveals the Data::ICal Perl module and some code that used Data::ICal to do something similar as I’ve planned (though only for the 2010 FIFA World Cup).

Say what you like about Perl, but CPAN rocks. Simple single statement and Data::ICal and all other necessary files are installed and working.

A couple of hours later (including a stop for lunch) and I have produced an ical file that will get imported into Google calendar. Main problem at the moment is that the timezone isn’t quite correct. Google calendar is showing the events 10 hours after they should have been – I think this is timezone related.

The big question now, “is there an easy way to delete all these entries?”. A google search reveals an option under setting for Google calendar.

Yep, slight change in the timezone setting and the times are okay. What about the dates?

Oops, week 12 dates showing up early (typo in hard-coded start date). Week 8 on a Tuesday, not Monday. Ahh, public holiday that Monday. So official week start date is the Tuesday. My code assumes the Monday. A more detailed version of this would need to figure out the public holidays. Same for week 9.

It’s all working

So, what’s been implemented is a script that

  • Automatically scrapes the institutional web page with timetabling information.
  • Extracts only the courses being taken by a student.
  • Generates an iCal file with the weekly personal class timetable.

Week 1 for me looks like the following. Click on the images to see a larger version.

Week 1

The monthly view on Google calendar, with one of the events highlighted looks like this

Monthly

Concept proven, work to do

It took me just over 3 hours to complete this. There was a break for lunch and most of the time was spent remembering how to interact with Perl and the Webfuse code.

This is not an “enterprise” solution, not yet. But it wouldn’t be that difficult to do. It’s certainly not impossible.

If you have followed some of my previous work or blog posts it will not be a surprise that I believe there are significant barriers in the processes around institutional IT systems that limit the possibility of these types of innovations.

Getting an overview of the term ahead

In the next couple of weeks I re-commence my face-to-face university education. This time in a Graduate Diploma in Learning and Teaching in order to become a high school teacher. As it’s less than two weeks from the start of term, the materials for the courses are now becoming ready. The following is an ad hoc collection of thoughts and experiences as I try to get an overview of the material and the term ahead.

Google being ruined?

Theoretically the institution is moving to Google Apps for Education for students. So the horrendous student email system originally being used is being replaced by gmail. It shall be interesting to see how the Google applications can be ruined by an institutional implementation.

Interesting to note that single-sign on still does not work for all applications. In this case getting the course profiles – the document serves as the “contract” between university and student – system requires another login.

Portals, timetables and ical

So there is a new look portal intended to bring everything into one place, to make life easier for students. However, it is still missing some fundamental elements. For example, a personalised class timetable, as I’ve complained about before.

There is a calendar in this new portal. Ahh, it’s Google calendar. But it’s not pre-populated with anything. I’m currently looking through the course profiles at the assessment. Slowly building up a calendar of due dates, wouldn’t it be nice if this could be done automatically? After all the institution has the due dates in a database, it knows which courses I’m enrolled in. At the very least, the ability to download an ical file or similar to import might be nice.

The absence of this sort of thing, especially if it remains absent in the long term, is another example of the problems facing institutional systems touched on briefly in the post around open source LMS. The IT folk at this institution are focused on package provision, not on the user. They will provide the calendar, but joining together two separate systems is not something they – or the applications – will do automatically.

Personal versus institutional

The other problem I face, is that I already have a gmail account, I already have a google calendar. I don’t want the institution to provide me with another gmail account and another google calendar. I want it to work with what I have. Ahh, there’s the Google docs link, I already use that.

Come on guys, catch up with the world.

Here’s an example. With the old student email systems – a web-based interface – the institution actually modified the system to remove the capability for students to forward email. So, instead of having the email all come nicely to the one place, I had another place to check.

So, can I automatically forward my new institutional gmail account? Yes, I can. It’s baked into gmail and I imagine they couldn’t convince (or pay) Google to remove it. Ahh, it’s also pop enabled, so I can bring it all into the one place (I use Thunderbird as an email client). Ahh, but will the screw around with hostnames, single signon get in the way? Yes, it appears like it does. Should I ask?

Bugger it, forwarding works. Will stick with that.

Of course, my decision here is another example of why institutional systems don’t improve. In the absence of anyone not complaining about the ability to use POP/IMAP the institutional IT folk will claim that there is no need for it, no-one wants it. It never occurs to them that people are smart enough (or cynical enough) to understand the futility of asking.

Of course, it now appears that forwarding may also not work. Actually, I just had to wait. It’s working now.

Bulk email to students

Oh dear, the uni is trying to increase response rates on student evaluation by bulk email to students from the institutional leader. At the very least you could limit this to students actually enrolled in the term. i.e. I was not enrolled in any courses during T3, 2010.

Assessment

By course the assignments are

  1. Course 1
    1. 40% – 10 “investigations” – 2000 words equivalent.
    2. 60% – 3000 word report, a range of supporting activity.
  2. Course 2
    1. 20% – Learning design brief, 1000 words – essentially a reflective blog (on first skim).
    2. 40% – Blog including 1600 word reflective synopsis.
      Oh dear, you have to upload your blog url via a Word document into Moodle. Have these folk not heard of BIM? It’s even installed.
    3. 40% – 2000 words – a learning design?
  3. Course 3
    1. 50% – Lessons plans, implementation and critical de-construction – 23 May
    2. 50% – Unit of work and evaluation – 6 June
  4. Course 4
    1. 50% – 2000 words report – 21 April
    2. 50% – 2000 word report – 26 May

bim2: Some more coordinator tabs

The last work on bim2 ended up with the first 2 of 5 tabs for the coordinator interface completed. This post continues on with that development.

Allocate markers

This is the tab which allows the coordinator to allocate different teaching staff to different groups of students. This structure arises from the context of the first institution to use BIM/BAM. In that context, it was not unusual for a course to have 10+ academic staff teaching the course, each responsible for a different cohort.

The basic algorithm for this tab is/was

  • If there are no teaching staff listed for the course, display a message and stop here.
  • If there are no groups for the course, display a message and stop here.
  • Otherwise, get all of the current bim marker allocations (stored in a bim table).
  • Display a form that contains a select menu for each marker. The menu contains all groups and highlights those that are allocated to the marker.
  • On submission, check the allocation to each marker and update database appropriately.

To a large extent this follows the same structure as the manage questions tab developed in the last post. This implies I’ll need to implement the following classes:

  1. allocate_markers – model.
    The data needed includes
    • List of all teaching staff for the course.
    • List of groups for the course.
    • List of bim2 marker allocations for this activity.
  2. allocate_markers_view – view.
    Which will implement much the same “structure” as the manage markers view in terms of displaying and processing the form.
  3. marker_allocations – object.
    Simple class to retrieve list of current marker allocations.
  4. bimtwo_allocation_form – the form.
    Moodle form class extension that implements the form.
  5. bimtwo_process_allocation_form – object.
    Processes the form on submission.

To do: The intent is that bim2 will recognise groupings, an aspect of Moodle’s operations that I have yet to grok. For now, I plan to ignore this and get a version of bim2 up and going. Given the OO structure, in theory it should not be difficult to come back and add support or groupings at a latter date.

Okay, that looks like it is working. The initial Allocate Markers page is very simple

Allocate markers

Just a list of teaching staff with a select menu full of course groups. The results of any processing are given a simple unordered list.

Allocate markers processing

There is a small problem with these images in that there are some missing images from the theme. They weren’t missing in the Manage questions dumps from earlier in the day. So I’m assuming there is some minor problem with the theme rather than a fundamental mistake in how I’m doing something in Moodle.

What’s next?

Hopefully tomorrow will see the last two coordinator tabs completed. Manage marking is a fairly simple in terms of form processing. “Your Students” is more complex, but it also serves as the interface for markers.

So, I’m hoping that the complete staff interface should be finished by Tuesday. i.e. most of bim2 will be working.

Then I move onto backups and other background tasks. Won’t be able to predict deadlines for those tasks until I take a closer look at the changes in backups for Moodle 2.

On the potential flexibility of open source LMS and its limits

Today a mate posted to his blog about a small project he’s involved with. The context of this project seems to be a good opportunity to comment on the potential flexibility of open source LMS and the limits of that flexibility within an institutional context. It’s also an attempt to link it back to the design theory described in my thesis (if you want more of the theory behind the following, look at the thesis).

The following uses Moodle as an example, but I believe that similar limitations exist regardless of the open source LMS. This is in part because a significant limit on the flexibility is not the LMS, but instead the institutional governance processes and associated factors..

The need

In this case, the need is to send students an email with a link to a survey. The link has been personalised based on the students’ membership of Moodle groups. They survey asks them to answer questions based on their experience of a group task.

My initial thought would be that this sounds like something Moodle should be able to do. Given the increasing emphasis on group related work I doubt that this is a novel requirement. So, there might be something in Moodle that can do this, however, based on my limited knowledge of Moodle I can’t think of anything off the top of my head.

I believe that there might be the functionality within Moodle to do each of the components of this task. There is probably a way to send emails to members of a group. There might even be a way to customise that email to some extent (there is a bulk email facility in Moodle 1.9, but, from memory, it seems somewhat limited). There is also probably a way to do a group-based survey (a MCQ might be the obvious solution).

But I doubt that there is an easy way to combine these separate functions so that the group email can automatically include the link to the group’s MCQ/survey.

Doing it outside of Moodle

There is another interesting and related comment in post describing this project

hile not ideal in that it is a separate system from the LMS, it is hoped that this trial will help inform the development of a Moodle module that will perform the same function albeit in a more integrated and seamless way

Over 6 months ago, I used to work at the institution being described. Based on that out-of-date experience, my initial guess is that “doing it outside of Moodle” is deemed to be easier than engaging with Moodle and the institutional IT department.

Two limits of open source LMS flexibility

Drawing on the above examples, I’d like to propose at least two, somewhat related limits on the flexibility of open source LMS:

  1. Inflexible institutional structures and processes.
  2. The difficulty of producing/the absence of scaffolding conglomerations.

Inflexible institutional structures and processes

Modifying an enterprise implementation of Moodle effectively and efficiently is hard. You don’t want your institution’s Moodle instance to be unavailable to students and staff because a code change has broken something drastically. The Moodle code-base is itself quite difficult to get a handle on. Not overly difficult, but a non-Moodle developer can’t simply front-up and start making changes quickly. They need to be enculturated into the Moodle way, to learn what works and what doesn’t. Such a requirements means that someone who is able to modify Moodle is often a scarce and expensive resources. Especially within most universities who often don’t have someone dedicated as a Moodle developer.

To address this difficulty and also to CYA (some might argue that CYA is the major reason) institution’s spend a lot of time and effort setting up appropriate governance structures. The theory being that these are objective and rational ways to manage the difficult process and the expensive and scarce resource.

The trouble is that the difficulty and expense involved means that it becomes difficult for such processes to effectively engage in “small” problems like this one. i.e. problems that don’t actually require development of any significantly new functionality or large-scale modules. It just needs a few minor changes or wrappers around existing functionality. For example, the requirement above could possibly be solved (the following is an example description given off the top of my head without any investigation as to whether this would work) by

  • Modifying the Moodle quiz function to populate a database table linking groups to URLs for group specific quizzes.
  • Modifying the existing Moodle bulk-email facility (or perhaps adding a wrapper around it like I did with bim) to use this database table to send personalised emails to group members.
  • Perhaps add a new quiz report that allows viewing/comparing within/across groups.

For a variety of reasons traditional institutional LMS policies and processes are too heavy-weight to respond to this sort of need. Instead, in order for something like this to be considered, it has to be blown up into some institutional priority. e.g. a system to support peer and group-based assessment for the entire institution. A project that will require a significant amount of time doing a needs analysis,……..

A big project that requires lots of resources is expensive enough to be efficiently considered by the governance and related processes. Small projects are too cheap to be efficiently considered by the expensive institutional processes.

In the hardware/operating systems field, this is a problem known as starvation or indefinite postponement. The situation where a task is forever ignored because of a flaw in the priority mechanism.

So, I’m proposing that the institutional implementation of open source LMS end up suffer from the “starvation limit” on flexibility.

The need for rapid development of scaffolding conglomerations

The need in this case, at least to me, sounds like an example of what I termed scaffolding, context-sensitive conglomerations. Rather than necessarily requiring a brand new Moodle module or block, this problem sounds like something that actually needs to combine the functionality from a number of existing Moodle services. Something that conglomerates the lower-level functionality provided by Moodle into something that better meets this higher-level need.

A large part of the popularity of Moodle arises from its modularity. A feature that allows for the easy development of lots of new functionality. Something that increases the flexibility of Moodle.

The problem is that this flexibility arises, in part, from keeping these different modules separate. It’s the separation that makes it easy to add a new function without (theoretically) worrying about how it will effect the other modules. They are meant to be independent. The current problems moving to Moodle 2.0 is an example of the problems that arise from dependency. All the third-party modules depend on the Moodle core, so when the Moodle core changes all the third-party modules have to change.

A strict separation between modules makes it more difficult to combine parts of these different modules into a scaffolding conglomeration.

So, I’m proposing that open source LMS have an “over reliance on module independence” that limits their flexibility.

It’s really all about balance

I can already here proponents of traditional institutional IT governance processes or strict software engineers bemoaning the problems of not having institutional governance or of module dependence. And I do agree. There are dangers and problems. I’m not suggesting that they should necessarily be done away with.

I do, however, think that too often the balance has gone too far one way. There needs to be more recognition of a need for balance the other way. A bit less of a focus on the objective, best ways of technical implementation, and a bit more on the subjective, best ways to improve learning and teaching.

bim2: Starting on the coordinator models

The last bit of work on bim2 set up the structure for the coordinator interface and operations. This post documents the work of implementing the models, i.e. starting the process by which the coordinator interface actually starts actually working. Most of this should be a reasonably straight translation/update of bim into the OO structure of bim2.

This post gets the first two tabs done. Three to go.

Configure

The aim here is to display basic configuration information and link to the standard configuration form. This is somewhat simpler because there’s already a class for doing this that is used by the student. So, will have to borrow that and perhaps add a bit more beside.

Yep, all done. Also discovered that the problem with help buttons was due to the theme I was using, not my use of Moodle. Progress!

Time to double check and get the actual configure process working. First, a win with the help buttons, finally figured out what I was doing wrong. Next was a bug in the database table to hold the configuration and now there is a problem with the description being saved. Yep, another transition mistake in moving to Moodle 2. Fixed. (Click on the screenshot below to see it larger).

configure

Manage questions

Most of the remaining tabs for a coordinator (except Manage marking) require the use of forms. Manage questions presents a form that contains space to add a question and form elements for each existing question. It’s used to modify, add and delete questions. Handling forms in this structure is a little different – and more complex – than what has happened so far. So, first step here is to re-acquaint myself with the kludge I used for the student form for registering a new blog.

The process is that the controller method remains essentially the same – create model, create view, pass model to view and use view’s display method – the difference is that the view embodies the Moodle form process. Which is essentially

  • Create a form object;
  • Implement 3 or so different options based on a value from the form object including: display the form, handle a cancellation and process the form contents (i.e. update the database).

Actually, that’s not too different. First step is to create the model. In this case the model has to know all about the questions for this bim2 activity. For which there is already a class, but it will need to be embedded in a model object. So, copy a model from the student over and update it to use the questions class. Done that was quite simple and the view is dumping its contents.

The step now is to use the data in the model to display and handle the form. The rough, initial version of the code looks like this


function display() {

    global $OUTPUT;
    global $CFG;

    // construct the form
    $cm_id = $this->model->factory->cm->id;
    $form = new mod_bimtwo_questions_form( "view.php?id=$cm_id" );

    if ( $form->is_cancelled() ) { 
        $this->view_header( "questions" );
        echo $OUTPUT->heading( "Manage questions" );
        $form->display();
    } else if ( $from_form = $form->get_data() ) { 
        echo $OUTPUT->heading( "Process the form" );
    } else {
        $this->view_header( "questions" );
        echo $OUTPUT->heading( "Manage questions" );
        $form->display();
    }   
            
    //print_object( $this->model->questions );
    $this->view_footer();
}   

What’s left to do is create the bimtwo_questions_form class and put in the real code to process the form.

The form class should be a straight copy and slight update of the form used in bim. Yep, that’s working fairly simply. Most of the work was involved with updating the language strings.

One extra bit of work is that the questions form from bim does assume the existence of an additional bit of information for each question, i.e. a status array showing number of students in each state. The question class in bim2 doesn’t support this, but I should be able to simply add a method, implement status and Robert is a parental male sibling. Done.

Now to process the form and update the database. First, the outline of the process from bim

  • If a title and post for a new question then add a new question.
  • Loop through each of the existing questions and do a range of checks for changes
  • Re-display the manage quesitons form.

In bim this is implemented as quite a long winded procedural function. Probably a candidate for methods or perhaps a new class. I’ll go the new class, don’t want to muddy the “view” waters with stuff that is manipulating
questions.

Forgot the function to add the question data into the form.

Okay, so have a processor object that is doing the form processing. Have implemented the checks for a new question and deleting questions. Also have adopted the approach where the view (which creates the processor) figures out how to display what was done. Time to move onto the handling of modification of existing questions. The process will be for each existing question

  • for each existing question
    • check if there has been any change;
    • if so, make a copy of the changes in “changed_question”
  • update the database with the changes;

Question: what happens if a question has already by deleted when it comes time to update? At the moment the question will have already been deleted from the database as deletion is handled first. So will prevent “deleted” questions from being modified.

Okay, now there is a problem with the update_record method, “update_record_raw() id field must be specified.” Appears for some reason that the structure being passed in is having all the fields cleared before insertion! Ahh, silly user error and unhelpful error message. I was using an old bim v1 table name, not the new version and Moodle wasn’t giving an error that suggested this as the problem.

With that fixed, manage question is working. Based on my naive understanding of good Moodle 2 practice I can no longer do the automatic redirect that bim v1.0 used. Instead, you start Manage Questions with the following page that shows a list of all existing questions and space to add a new one.

Manage Questions

You make your changes on that page and hit one of the submit buttons. bim2 then processes the changes and displays details about what happened.

Manage questions update

There is a link at the bottom of that page to return to the first Manage Questions page. In bim1, this would have been where the automatic re-direct would’ve happened.

What’s next?

Well, that’s two of the coordinator tabs down. Another three to go. Will start another post for those.

Standardised testing is bad, but what is the alternative?

Spent yesterday playing cricket in the local competition. A first step in returning to a “normal” life. As it happens one of the guys I was playing with – and have known for a long time – is also a Deputy Principal at one of the local primary schools. He asked if I was still working at the Uni and I explained no, I was heading into high school teaching. From there the discussion turned to teaching and its issues and benefits. Before too long I asked about NAPLAN testing and its impact. “It’s all we’re teaching at the moment”, was the response, essentially much the same as I I mentioned in a previous post.

Over the last six months or so, I’ve been listening to and reading a lot of K12 education related material. All of it, especially that by folk with first-hand knowledge of actual teaching, has been aware of the negative implications of standardised testing, especially when tied to rankings or funding. It corrupts the teaching process and becomes the almost primary focus of learning. At the core, this seems to be a wonderful example of Goodhart’s law which Wikipedia describes as

states that once a social or economic indicator or other surrogate measure is made a target for the purpose of conducting social or economic policy, then it will lose the information content that would qualify it to play such a role

It is obvious that school performance on the NAPLAN test has become a target. School’s and teachers are being told by regional management to focus on improving performance on that target. Consequently, I believe that NAPLAN test scores have lost any value, the information content in such scores does not represent the quality of education. It represents how well the educators have been able to prime students for the test. More importantly, it fails to measure what has been lost in the chase for good NAPLAN scores.

What is the alternative

The idea of standardised testing, like the NAPLAN tests, arise from the idea of managerialisation which is seen by some as a key component of globalisation. It is the idea that it is important for government to measure and assure the quality of services like education. Measurement that requires objective, quantifiable measures. It is unlikely that this requirement for measurement is going to disappear anytime soon.

Given, as described above, that I believe the current approach to this measurement is having extremely negative effects on what it is trying to measure. Then the question is, what are the alternatives? Is there a way to provide government and society with the “measurement” that shows the quality of the education being provided to children?

Surely there has to be some folk within the educational research community coming up with alternatives? Even some folk trying them out in real education settings.

This is not a problem limited to K12 education. Universities, especially those in Australia, are increasingly having to deal with this problem and they aren’t doing it any better.

This is likely to become one of my underlying questions for the next year or so.

bim2: the greater coordinator conversion

This tells the story of the conversion of the bim coordinator code into the new OO design being used for bim2.

Design

The theory is that the code design should share a lot of similarity with the student interface and also some code.

First, a recap of how it works (solely for my benefit).

The main view.php entry point for bim2 contains 3 lines of code

$factory = new bimtwo_controller_factory();
$controller = $factory->produce();
$controller->process();

The factory determines which of three types of user has requested the activity

  1. coordinator;
  2. marker; or
  3. student.

Each user type has a controller object, the factory creates the appropriate object and view.php calls that object’s process method.

The controller defines a hash called methods which associates a parameter called tab (passed in from the URL) with a method in the controller. For students, it looks like this

$this->methods = array(
    "default" => array( "default" => "activity_details" ),
    "activity" => array( "default" => "activity_details" ),
    "questions" => array( "default" => "questions" ),
    "posts" => array( "default" => "posts" )
);

Typically, there is a connection between the values of tab and a tabbed interface for the user.

Typically, that method will create a model object that will generate some data and then create a view object. It will pass the model to the view and the view will display some output.

For example, here’s the method for showing the questions for the activity to the students

    function questions() {
        require_once "$this->view_path/student/question_details.php";
        $this->model = new question_details( $this );
        $this->model->gather_data();
        require_once "$this->view_path/student/question_details_view.php";
        $this->view = new question_details_view( $this );
        $this->view->display( $this );
    }

In theory, the question_details model object should be able to be re-used by the coordinator interface. Maybe even the view.

Creating the dummy coordinator design – views

So the plan is to initially create a coordinator controller that displays the tabs etc, but simply displays “hello world” type messages for each tab. Once that’s working, it’s a matter of implementing the model and view objects for each tab – and also implementing the forms interface where required.

So, the simple first step is to copy the student controller and edit it. Done. So, now login as a coordinator and see if it works?

Yep, after a couple of syntax errors it is working. The coordinator controller methods are the bare minimum e.g.

    function configure() {
        print "<h1> Configure </h1>";
    }

    function manage_questions() {
        print "<h1> Manage questions </h1>";
    }

So, there are no proper Moodle header/footer and no proper tabbed interface. The construction of these is controlled by the views. So the next step is to create view classes for each of the methods that handle the header/footer/tabs but still only display the “hello world” type message. There is one view per controller method. Time to get that working.

The configure tab is a little different, in that it is meant to re-use a standard form/process for Moodle. Will leave that for later and get the other views working first. Manage questions first. Copy the student/posts_view.php class over and edit that.

Yep, that all works. It does, however, reveal a couple of points to check, including:

  • Currently, the view object has a view_header function that is repeated in each view object. I believe this can be inherited.
    Actually, it can quite easily. Add a few lines to the parent view class and hey presto.
  • The order in which the tabs being displayed is not in the order I’d prefer. Need to find out how to order tabs.
    Leave this for now.

So, with the views relying on the parent for view_header this is working for Manage questions. Now just to add it for all the others. Yep, that’s all working, except for configure (and the order of the tabs which is annoyingly incorrect).

Apart from that, this has gone quite smoothly and quickly.

Calling configure

Ahh, had a vague recollection that there was a specific edit form for configuration, and there is. But the solution adopted in bim (and to be repeated for bim2) is that the configure tab for the coordinator will show the details of the current configuration for this activity and include a link to the Moodle defined edit form to change the configuration.

The point to remember is that when a bim2 activity is first created, Moodle directs appropriately permitted users to the edit form. once configure it shows what I’m working on here.

Short story is that the configure tab is now different from the others in terms of view.

Order of tabs

Ahh, a little bit of digging reveals that this is not a Moodle core problem. It’s doing what should be done and retaining the order. It’s the Moodle theme I was using that wasn’t putting the tabs in the right order. Will have to let @rolley know.

Of course, the next step is to find a theme that does it properly. first attempt did it, but had too narrow a column and didn’t handle the wrapping well. Somewhat influenced by my practice of keeping fairly narrow browser windows.

Models and views

At this stage, the basic structure for the coordinator interface is there and working (if not doing anything useful).

The next step is to go through each controller method and

  • Implement the model that gets the required data.
  • Modify the view to display that data appropriately.
  • Add the “form handling” extras where required.
    For the coordinator, most of the methods will require some form handling, this makes things a little more complex.

I’ll leave these for tomorrow. Each of these will take a bit of time, so will probably do them as separate posts.

Update the student views

Before I finish, however, I need to update the student views to remove their specific view_header method and instead rely on the parent class based on what I added above.

Done, however, the activity_details_view is a little more complicated.

A little bim2 status and planning

The purpose of this post is to make concrete the status and future plans around bim2. The update of bim for Moodle 2.0.

Current status

I have missed the initial deadline (31/01/2011) for a working bim2. <excuses>A combination of the PhD being more important, procrastination and a post-thesis malaise.</excuses>

I’ve just finished the first major stage of bim2 development tonight. The code for bim2 on github will

  • Support creation of a bim2 activity.
    Though I’ve just discovered a minor bug. Will fix that.
  • Implements the complete student interface including registering and processing a new blog and viewing details. Some images follow (click on the images to see a larger version).

Activity details

Questions

Posts

This doesn’t sound much, that’s because the more important stuff is what has gone on behind the scenes, including

  • Design and implementation of a new OO design for bim2.
    This is perhaps the most questionable part of the changes for bim2. In theory, the changes should make it easier to evolve, but the ad hoc, half-forgotten OO design skills employed may put pay to that.
  • Get bim2 to use the Moodle 2 version of simplepie.
    The biggest problem reported by folk hosting Moodle is that bim required an external module called simplepie which was quite large. Moodle 2 has simplepie baked in. bim2 is using that version.
  • Feed processing.
    Beyond the use of Simplepie, bim has to be able to process and mirror student feeds. This has been done as part of the student interface and will be re-used elsewhere.
  • Get around changes in Moodle 2.
    Mostly fairly minor, but still changes to become aware of.

What’s important is that the rest of bim2 will essentially be re-using all of the above. There’s little brand-new to learn. Hopefully this means things will go quickly from here.

Planning

In terms of getting a reasonable working version of bim2 available for folk, the major steps are

  1. Implement the coordinator interface.
    The coordinator is responsible for a bim2 activity and is able to configure the activity, manage questions, allocate markers, manage marking, search for students and mark students.
  2. Implement the marker interface.
    Markers are teaching staff who can’t do some of the more advanced coordinator tasks, just the subset of marking students. This task should simply be a “re-badging” of the coordinator code.
  3. Look at the various background/support tasks.
    The main one is probably going to be the backup and restore process.
  4. Clean up and test.
    There are some minor, fiddly tasks I’m leaving until this stage (beyond a detailed testing of the code) such as getting all of the help text working well.
  5. Add new features.
    There are plans to add a range of features to bim2 that were not in bim (e.g. working with Moodle groupings etc.). These additions will be left to last.
  6. Get feedback from others.
    There are a couple of groups eager to test out the mess I’ve made of bim2. They will almost certainly have good feedback that will need to be incorporated.
  7. Work out how to release bim2 more formally.
    Mostly this is to do with the Moodle plugins database and/or its replacement.

The plan is that the first 4 tasks will be done sequentially. The last three might happen in parallel or in different orders. It might take me a good week of work to get the coordinator interface going, but it might go much faster. All depends on how quickly the porting of bim into bim2 OO goes. After that, however, the marker interface should just about write itself. The background stuff might drag or might go quick, don’t know enough yet.

So, it’s probably 3 or 4 weeks. Time to get cracking.

bim2: registering a new blog

The following continues the coding of the bim2 process for registering and processing a new student feed.
It’s taken a couple of weeks, but it is working with only a few minor tweaks and nudges remaining.

Steps involved will be

  • saving feed details to the database;
    Not something I’ve in Moodle 2. yet.
  • figure out how to process the feed;
  • generate appropriate successful output;
  • generate useful errors.

Most of these are going to reuse basic algorithms from bim, but will have to be re-written to fit with the changes in Moodle 2 and also the OO design for bim2.

Save feed details

Main requirement is to update bimtwo_student_feeds with information about: number of entries, date of last post, blogurl and feedurl.

That was surprisingly easy.

Handling errors

The possible situations with entry of new feeds include

  • DONE It is a URL and a valid feed can be found;
  • DONE It isn’t a URL;
    This is handled by the form and Moodle.
  • DONEThe URL points directly to a feed;
    Handled using simplepie’s features (e.g. get_permalink)
  • DONEIt is a URL, but there is not feed associated with it;
  • DONEThere is a feed, but there are problems retrieving it.
  • DONEThere is a (purported) feed, but there are problems with the format of the feed.
  • DONEThe possibility that the user has entered some known “bad urls”.
    e.g. http://wordpress.com/ is a common entry, while it has an associated feed it is unlikely that a student will be using that.

All of the remaining uncompleted tasks (except the last) are handled by simplepie. The last one is a bim addition, which I think for now we’ll postpone. So, have to update bim2 to display the simplepie errors “nicely”.

Next, is to get bim2 to check for some standard wordpress.com mistakes. This is primarily historical and should probably be expanded if folk become aware of other common mistakes.

Processing the feed

The factor that makes this task a little more difficult is that “processing the feed” will eventually be something bim will also have to do with all feeds. Since this can be quite a large list, it would be good for it to be efficient to work on all feeds, but also not duplicate between the register single and process all requirements.

Processing a feed basically means looking at what is already stored in the bimtwo_marking table and comparing that with what is in the most up to date version of the feed. If there are any new posts, then those posts need to be inserted into bimtwo_marking and the bimtwo_student_feeds entry needs to be updated (lastpost and num entries).

In bim, this was done with a function bim_process_feed which takes the bim activity id, feed details and a list of the questions for the bim. The function then

  • Uses simplepie to get the most recent version of the feed;
  • Get the contents of the marking table for the user (what posts for this user are already in the database)
  • Creates a hash based on the link to each post within the database already that gives access directly to the contents of the marking database
  • Uses that hash to identify the questions that haven’t been answered yet.
  • For each of the items in the feed
    • Checks to see if it is already in the database via the hash.
    • If not
      • Converts the content of the message to UTF-8
      • Loops through all the questions to see if it is an answer to a question.
      • Inserts it into the database.
      • Updates the lastpost and numentries variables (for later update)

There might be some speed increase if the database insertion was held off until the end and done all in one, but am not going to play that game. Need to think about how this can be implemented.

How’s this

$process = new bimtwo_process_feed( $this->bimtwo, $this->feed, $questions, $this->simplepie );
$process->process_feed();
$this->update_feed_details( $process );

A new class solely for processing the feed. This same code can be re-used when processing all feeds as when processing a single feed. The first three parameters are necessary: the id of the bim activity (bimtwo), the URL for the feed, the array of questions set for this activity, and an optional simplepie object.

The idea is that without the simplepie object, this class would construct its own simplepie object and use it to process the feed. When registering a single student feed, we already have a simplepie object, so wish to avoid the overhead of re-creating it. We won’t have this when working on a list of feeds.

Okay, that’s all working. In the end, the “update_feed_details” function is removed.

Forms and redirection

The question I’m looking at now is how to handle the “success” case. i.e. the form with the new blog url is submitted and all the processing complete successfully. Want to display some sort of success message and then show the details of the results of the processing. i.e. the normal default page for the student, but with a success message.

It looks like I should use a redirect, but perhaps with an extra parameter to indicate successful registration which is then used by the existing code. I think that’s the way to go. How to do the redirect/formulate the URL.

Some stories from teaching awards

This particular post tells some personal stories about teaching awards within Australian higher education. It’s inspired by a tweet or two from @jonpowles

Some personal success

For my sins, I was the “recipient of the Vice-Chancellor’s Award for Quality Teaching for the Year 2000”. The citation includes

in recoginition of demonstrated outstanding practices in teaching and learning at…., and in recognition of his contribution to the development of online learning and web-based teaching within the University and beyond

I remain a little annoyed that this was pre-ALTC. The potential extra funds from a national citation would have help the professional development fund. But the real problems with this award was the message I received about the value of teaching to the institution from this experience. Here’s a quick summary. (BTW, the institutional teaching awards had been going for at least 2 or 3 years before 2000, this was not the first time they’d done this.)

Jumping through hoops

As part of the application process, I had to create evidence to justify that my teaching was good quality. That’s a fairly standard process.

What troubled me then and troubles me to this day, is that the institution had no way of knowing. It’s core business is learning and teaching and it had no mechanisms in place that could identify the good and the bad teachers.

In fact, at that stage the institution didn’t have a teaching evaluation system. One of my “contributions to the development of online learning” was developing a web-based survey mechanism that I used in my own publications. This publication reports response rates of between 29-41% in one of my courses.

It is my understanding that the 2010 institutional evaluation system still dreams about reaching percentages that high.

Copy editing as a notification mechanism

Want to know how I found out I’d won the award? It was when an admin assistant from the L&T division rang me up and asked me to approve the wording of the citation.

Apparently, the Vice-Chancellor had been busy and/or away and hadn’t yet officially signed off on the result, or that I could be officially notified. However, the date for the graduation ceremony at which the award was to be given was fast approaching. In order to get the citation printed, framed and physically available at the ceremony the folk responsible for implementation had to go ahead and ask me to check the copy.

Seeing the other applications

I actually don’t remember exactly how this happened. I believe it was part of checking the copy of the citation, however it happened I ended up with a package that contained the submissions from all of the other applicants.

Double dipping

The award brought with it some financial reward, both at the faculty level (winning the faculty award was the first step) and the university level. The trouble was that even this part of the process was flawed. Though it was flawed in my favour. I got paid twice!

The money went into a professional development fund that was used for conference travel, equipment etc. Imagine my surprise and delight when my professional development fund received the reward, twice.

You didn’t make a difference

A significant part of the reason for the reward was my work in online learning and, in particular, the development of the Webfuse e-learning system. Parts of which are still in use at the institution and the story is told in more detail in my thesis.

About 4 years after receiving this award, recognising the contribution, a new Dean told me not to worry about working on Webfuse anymore, it had made no significant different to learning and teaching within the faculty.

Mixed messages and other errors

Can you see how the above experience might make someone a touch cynical about the value of teaching awards? It certainly didn’t appear to me that the recognition of quality teaching was so essential to the institution’s operations that they had efficient and effective processes. Instead it felt that the teaching award was just some add on. Not to mention a very subjective add on at that.

But the mixed messages didn’t stop there. They continued on with the rise of the ALTC. Some additional observed “errors”.

Invest at the tail end

With the rise of the ALTC it became increasingly important that an institution and its staff be seen to receive teaching citations. The number of ALTC teaching citations received became a KPI on management plans. Resources started to be assigned to ensuring the awarding of ALTC citations.

Obviously those resources were invested at the input stage of the process. Into the teaching environment to encourage and enable university staff to engage in quality learning and teaching. No.

Instead it was invested in hiring part-time staff to write the assist in the writing of the ALTC citation applications. It was invested in performing additional teaching evaluations for the institutional teaching award winners to cover up the shortcomings (read absence) of an effective broad-scale teaching evaluation system. It was invested in bringing ALTC winners onto campus to give “rah-rah” speeches about the value of teaching quality and “how I did it” pointers.

Reward the individual, not the team

Later in my career I briefly – in-between organisational restructures – was responsible for the curriculum design and development unit at the institution. During that time, a very talented curriculum designers worked very hard and very well with a keen and talented accounting academic to entirely re-design an Accounting course. The re-design incorporated all the right educational buzz words – “cognitive apprenticeship” – and the current ed tech fads – Second Life – and was a great success. Within a year or two the accounting academic received an institutional award and then an ALTC citation.

The problem was that the work the citation was for, could never have been completed by the academic alone. Without the curriculum designer involved – and the sheer amount of effort she invested in the project – the work would never have happened. Not unsurprisingly, the curriculum designer was somewhat miffed.

But it goes deeper than that. The work would not also have been possible without the efforts of a range of staff within the curriculum design unit, not to mention a whole range of other teaching staff (this course often has 10s of teaching staff at multiple campuses).

I know there are some ALTC citations that have been awarded to teams, but most ALTC citations are to individuals and this is certainly one example where a team missed out.

Attempt to repeat the success and fail to recognise diversity

But it goes deeper than that. The work for this course was not planned. It did not result from senior management developing a strategic plan that was translated into a management plan that informed decision making of some group that decided to invest X resources in Y projects to achieve Z goals.

It was all happenstance. There were the right people in the right place at the right time and they were encouraged and enable to run with their ideas. Some of the ideas were a bit silly, they had to be worked around, manipulated and cut back, but it was through a messy process of context-sensitive, collaboration between talented people that this good work arose.

Ignoring this perception, some folk then mistakenly tried to transplant the approach taken in this course into other courses. The failed to recognise that “lightning doesn’t strike twice”. You couldn’t transplant a successful approach from one course context into another. What you really had to do was start another messy process of context-sensitive, collaboration between talented people.

Quality teaching has to be embedded

This bring me back to some of the points that I made about the demise of the ALTC. Quality teaching doesn’t arise from external bodies and their actions, it arises from conditions within an university that enable and encourage messy processes of context-sensitive, collaboration between talented people.