Some early results from Webfuse evaluation

The following contains some early results from the evaluation of Webfuse course sites as mentioned in the last post. The aim is to get a rough initial feel for how the course sites created for Webfuse in the late 90s and early 00s stack up using the framework produced by Malikowski et al (2007). As opposed to other PhD work, this is a case of “showing the working”.

How many page types?

First, let’s see how many page types were used each year. The following table summarises the total number of pages and number of different page types (in some years there were page types with different names that had only very slightly different functionality – the following stats are rough and don’t take that into account) used in each year.

Year # pages # page Types
1999 4376 27
2000 3058 39
2001 1155 23
2002 9099 42
2003 9302 40

Can see from the above that the number of overall pages managed in Webfuse drops significant drop from 2000 to 2001. 2001 is when the new default course site structure was put in place and when (I think) the courses 85321 and 85349 (which I taught) stopped included the archives of previous offerings. Check this. May need to look at excluding from consideration some of these?

During this time there were some page types which had different names, so would be counted more than once in the above, but were essentially the same. Count the same page types once.

I have to save the commands to do this somewhere, may as well do it here

find . -name CONTENT -exec grep PageType \{\} ; > all.pageTypes
sed -e '1,$s//\1/' all.pageTypes | sort | uniq -c > all.pageTypes.count

Calculate the percentage of page type usage per framework

The next step is a simple calculation. Allocate each page type to one of one of the categories of the Malikowski et al (2007) framework and show the percentage of the pages managed by Webfuse that fall into each category. This isn’t exactly what Malikowski et al (2007) count, the count the percentage of courses that use features in each category.

The Malikowski et al (2007) framework includes the following categories:

  • transmitting content;
  • creating class interactions;
  • evaluating students;
  • evaluating course and instructors;
  • computer based instruction.
    Not included – there are no Webfuse page types that provide functionality that fits with this category.

The following table shows the percentage of pages managed by Webfuse that fall into each category per year. It’s fairly obvious from the first year done – 1999, and confirmed with the second, that this approach doesn’t really say a lot. Time to move on.

Category 1999 2000 2001 2002 2003
Transmitting content 97.5% 84.5%
Class interactions 1.9% 13.5%
Evaluating students 0.1% 1.5%
Evaluating course 0.5% 0.6%

Calculate the % of courses using each category

In this stage I need to:

  • Count the number of courses in each year.
  • Count the % of courses that have features of each category.

Technically, all of these courses will have features for transmitting content, so all those will be 100%, so I’ve not included it. Need to recheck the Malikowski definition.

Also, 2001 seems to be missing a couple of the main terms, so it’s had to be excluded – for now. See if the missing terms can be retrieved.

Category 1999 2000 2002 2003
Number of course sites 190 175 315 309
Class interactions 7.9% 43.5% 11% 66.6%
Evaluating students 2.6% 6.3% 12% 21.7%
Evaluating course 9.5% 7.5% 14% 91.6%

Commands I used to generate the above

find aut2000 spr2000 win2000 -name CONTENT -exec grep -H PageType \{\} \; > course.pageTypes to get period/course:pageTypeName
sort course.pageTypes | uniq  | sort -t: -k2 > course.pageTypes.uniq
... edit to move the page types around

Now, there are some interesting results in the above. Have to check the 2000 and 2002 result for class interactions, unusual dip..

The almost 92% of courses with a course evaluation feature in 2003 is due to the raise of the course barometer explained in Jones (2002)

Too late to reflect anymore on this. Off to bed.


David Jones, Student feedback, anonymity, observable change and course barometers, World Conference on Educational Multimedia, Hypermedia and Telecommunications, Denver, Colorado, June 2002, pp. 884-889.

Malikowski, S., Thompson, M., & Theis, J. (2007). A model for research into course management systems: bridging technology and learning theory. Journal of Educational Computing Research, 36(2), 149-173.

Thinking about evaluating Webfuse (1996 through 1999) – evaluation of an LMS?

For the last couple of weeks I’ve been working on chapter 4 of my thesis. I’ve worked my way through explaining the context (general context and (use of e-learning), the design guidelines and the implementation (parts 1, 2 and 3). I’ve now reached the evaluation section, where I’m meant to describe what happened with the use of Webfuse and make some judgement calls about how it went.

The purpose of this post is to make concrete what I’m thinking about doing. A sort of planning document. I don’t think it will be of much use to most others, though the following section on related work might be some interest.

Other related work

Indicators project

Col and Ken, two colleagues at CQU have started the indicators project which is seeking to provide academics with tools to reflect on their own usage of LMSes. There most recent presentation is up on Slideshare (where’s the video Col?).

They are currently drawing primarily on data from the Blackboard LMS which was used at CQU from about 2004 through 2009. Webfuse was essentially a parallel system, but it ran from 1997 through 2009. Both are being replaced by Moodle in 2009.

At some stage, I am hoping to mirror the work they are doing with Blackboard on Webfuse. This will complete the picture to encompass all e-learning at CQU and also potentially provide some interesting comparisons between Webfuse and Blackboard. This will be somewhat problematic as there are differences in assumptions between Webfuse and Blackboard. For example, Webfuse generally doesn’t require students to login to visit the course website. Most are freely available.

Some of the data from Ken’s and Col’s presentation about Blackboard:

  • 5147 courses – would be interesting to hear the definition of course as a number of Blackboard courses during this period were simply pointers to Webfuse courses.
  • Feature adoption using a framework adopted from Malikowski (2007) as a percentage of online courses from 2005 through 2009
    • Files: ranging from 50% to 78%
      Which raises the question, what did the other 22-50% of courses have in them, if no files? Just HTML?
    • News/Announcements: ranging from 77% to 91% (with a peak in 2007.
    • Gradebook: ranging from 17% to 41%
    • Forums: ranging from 28% to 61%
    • Quizzes: ranging from 8 through 15%
    • Assignment submission: ranging from 4 to 20%.

    An interesting peak: In most of the “lower level” features there seems to have been a peak, in percentage terms, in 2007. What does that mean? A similar, though to less an extent peak is visible in the forums, quizzes and assignment submission categories.

    Might be interesting to see these figures as a percentage of students. Or perhaps with courses broken down into categories such as: predominantly AIC (CQU’s international campuses), predominantly CQ campuses, predominantly distance education, large (300+ students), small, complex (5+ teaching staff), simple.

  • Hits on the course site
    There’s a couple of graphs that show big peak at the start of term with slow dropping off, with the occasional peak during term.

    It might be interesting to see the hit counts for those courses that don’t have discussion forums, quizzes or assignment submission. I feel that these are the only reasons there might be peaks as the term progresses as students use these facilities for assessment.

  • Student visits and grades.
    There are a few graphs that show a potentially clear connection between number of visits on a course site and the final grade (e.g. High Distinction students – top grade – average bit over 500 hits, students who fail average just over 150 hits). It is more pronounced for distance education students than for on-campus students (e.g. distance ed high distinction students average almost 900 hits).
  • Average hits by campus.
    Distance education students averaged almost 600 hits. Students at the AICs, less than 150.
  • Average files per course in term 1.
    Grown from just over 10 in 2005 to just over 30 in 2009.

    I wonder how much of this is through gradual accretion? In my experience most course sites are created by copying the course site from last term and then making some additions/modifications. Under this model, it might be possible for the average number of files to grow because the old files aren’t being deleted.

Malikowski, Thompson and Theis

Malikowski et al (2007) proposed a model for evaluation the use of course management systems. The following figure is from their paper. I’ve made use of their work when examining the quantity of usage of features (read this if you want more information on their work) of an LMS in my thesis.

Malikowski Flow Chart

Purpose of the evaluation

The design guidelines underpinning Webfuse in this period were:

  • Webfuse will be a web publishing tool
  • Webfuse will be an integrated online learning environment
  • Webfuse will be eclectic, yet integrated
  • Webfuse will be flexible and support diversity
  • Webfuse will seek to encourage adoption

I’m assuming that the evaluation should focus on the achievement (or not) of those guidelines. The limitations I have is that I’m restricted to archives of websites and system logs. I won’t be asking people as this was 1996 to 1999.

Some initial ideas, at least for a starting place:

  • Webfuse will be a web publishing tool
    How many websites did it manage? How many web pages on those sites? How much were the used by both readers and authors?
  • Webfuse will be an integrated online learning environment
    Perhaps use the model of Malikowski et al (2007) to summarise the “learning” functions that were present in the course sites. Some repeat of figures from the above.

    I recognise this doesn’t really say much about learning. But you can’t really effectively judge learning any better when using automated analysis of system logs.

  • Webfuse will be eclectic, yet integrated
    This will come down to the nature of the structure/implementation of Webfuse. i.e. it was eclectic, yet integrated
  • Webfuse will be flexible and support diversity
    Examine the diversity of usage (not much). Flexibility will arise to some extent from the different systems implemented.
  • Webfuse will seek to encourage adoption.
    This will come back to the figures above. Can be a reflection on the statistics outlined in the first two guidelines.


So, there’s a rough idea of what I’m going to do, what about a rough idea of how to implement it? I have access to copies of the course websites for 1998 and 1999. I’m hoping to have access to the 1997 course sites in the next couple of weeks, but it may not happen – some things are just lost to time – though the wayback machine may be able to help out there. I also have the system logs from 1997 onwards.

In terms of meeting Malikowski et al’s (2007) framework, I’ll need to

  • Unpack each year’s set of course websites.
  • Get a list of all the page types used in those sites.
  • Categories those page types into the Malikowski framework.
  • Calculate percentages.

In terms of looking at the files uploaded to the sites, I’ll need to repeat the above, but this time on all the files and exclude those that were produced by Webfuse.

Author updates – I can parse the web server logs for the staff who are updating pages. The same parsing will be able to get records for any students who had to login. This will be a minority.


Malikowski, S., Thompson, M., & Theis, J. (2007). A model for research into course management systems: bridging technology and learning theory. Journal of Educational Computing Research, 36(2), 149-173.

Gaps, shadow systems and the VLE/LMS

One of my continuing “rants” that long-time readers of this blog will be familiar with is the lack of fit between enterprise systems and what people want to do with them. I’ve blogged about this with enterprise systems, learned to live and thrive in spite of that gap and drawn some lessons from it for enterprise systems.

It’s even become a bit of a family activity with my wife’s Masters research being aimed at attempting to explain the most common response to the lack of fit between people’s requirements and the enterprise systems put in place to fulfill them – shadow systems. The following image is of the model that arose out of Sandy’s work (Behrens and Sedera, 2004).

Sandy's Shadow System Model

One description of the model is that a gap arises (almost inevitably in my opinion) between the enterprise system and the needs of the users. It is created by a range of conditions and can be increased or reduced by two others. The existence of this gap leads to the development of shadow systems. These might simply be employing lots of other people to perform tasks manually that a system should provide. Or it might include developing additional systems to fill the gap.

The gap, shadow systems and the VLE/LMS

My current institution is in the process of adopting Moodle as its sole VLE/LMS. From one perspective Moodle will become another enterprise system supported by the IT folk to achieve business outcomes. That’s certainly one perspective of how Moodle is being rolled out at the institution. For me this raises some interesting questions:

  • Will Moodle suffer the same problems in terms of the gap and shadow system as other enterprise systems?
    I tend to think this is almost certain to happen given the diversity and contrary nature of academics, the diversity inherent in L&T, attempts at the institution to standardise L&T at the same minimum and on-going lack of institutional support for L&T.
  • What form will those shadow systems take?
    The rise of social media, web 2.0 etc tools and their broader use by academics – especially those in the younger generation – and students offers one likely source of the shadow systems.
  • How will the organisation respond?
    The traditional, almost reactionary, response from organisations is that shadow systems are evil and need to be stamped out. That is, if the organisation even becomes aware of them.
  • What are more appropriate ways for the organisation to respond?
    Some colleagues and I have made suggestions previously.
  • Where will the gaps arise?

Where will the gaps arise? An example.

Thomas Duggan another member of staff at my current institution has recently posted an outline of a paper he is working on which seems to detail one of the sources for the gap. It’s a source that seems to potentially fall within the “People” causal condition from Sandy’s model above.

Tom teaches at the institution’s indigenous learning centre Nulloo Yumbah. The paper Tom is working on is built on literature around indigenous learning styles and seeks to see how well Moodle can accommodate those styles. It will be interesting to see what he finds out.

My guess is that how well Moodle will fit these learning styles will depend on many of the factors covered in Sandy’s model. For example:

  • Technology/People;
    Moodle is meant to embody/support a specific learning theory. If you accept that (I still question it) there will be a good fit if that learning theory matches the indigenous learning styles as outlined in the literature Tom is drawing up. If the Moodle learning theory and the indigenous learning styles don’t match, then there will be trouble.
  • Organisation;
    Much is made of Moodle being open source and open source meaning flexible and able to be changed. This point was pushed quite hard in the various sessions promoting Moodle at the institution. However, such a point misses the significant role played by the policies adopted by an institution implementing Moodle. Open source might mean more flexibility, but if the organisation decides to implement as vanilla, that is meaningless. If the organisation doesn’t set up the resources and processes to support and inform that flexiblity, then open source is meaningless.
  • Business processes;
    The institution as adopted a minimum standard for online courses. If there is a mismatch between the indigenous learning styles and the minimum standards, then it might be interesting.
  • Organisation (again);
    The minimum standards are mostly (almost entirely) being driven by the two faculties at our institution and their management. Nulloo Yumbah and the courses it teachers do not, I believe, fit within a faculty. Perhaps the minimum standards don’t apply, or don’t apply as strictly.
  • People; and
    Tom has a background in technology. This means that even if there is a mismatch between Moodle and the indigenous learning styles he may be able to come up with kludges within Moodle that overcome that mismatch. In part, this will come from Tom really understanding the Moodle model and then being able to innovate around it.
  • People (again).
    Tom, through the blogosphere, twitter and general disposition has established social networks with a range of people that also have experience in L&T and technology, including e-learning. He’s also likely to be able to draw upon those people to come up with workarounds to any gaps.

Just one example

There will be anywhere from about 500 to 1000 courses at this institution that will have to go into Moodle over the next year or so. The above process/set of conditions is likely to apply in each of them. There will be a large number of people having to go through this process. My fear/belief is that most of them, because of a range of contextual and personal reasons, simply won’t bother. They will do the bare minimum of work necessary to meet the set minimal standard and won’t bother overcoming the gap that exists.

Another fear is that many of the people who want to overcome the gaps won’t have the knowledge, time or support to overcome the gap. Instead they will have to make do with what they have and over time get increasingly dispirited.

Lastly, those people that have the knowledge and time (a very small minority) will spend a large amount of time experimenting and will end up developing workarounds. The knowledge that goes into those workarounds will never be captured and disseminated, which makes it likely that many people will repeat the exploration process over and over again. Make the same mistakes and reinvent the wheel. Worse, few or none of these people will be recognised.


Well, there’s probably quite a few interesting little research projects and publications in keeping a close eye on how this rolls out. What are the gaps that people face?

Even more interesting would be putting in processes and resources that would enable people to effectively respond to these gaps. And this doesn’t mean using the traditional process for requirements gathering with enterprise systems.


Sandy Behrens, Wasana Sedera, (2004) Why do Shadow Systems Exist after an ERP Implementation? Lessons from a Case Study, Proceedings of PACIS’2004, Shanghai, China

David Jones, How to live with ERP systems and thrive, Presented at the Tertiary Education Management Conference’2003, Adelaide

Jones, D., Behrens, S., Jamieson, K., & Tansley, E. (2004). The rise and fall of a shadow system: Lessons for enterprise system implementation. Paper presented at the Managing New Wave Information Systems: Enterprise, Government and Society, Proceedings of the 15th Australasian Conference on Information Systems, Hobart, Tasmania.

BAM into Moodle #9 – a working eStudyGuide block?

The last post finalised some bits of knowledge I needed, now it is time to put it into action and complete the eStudyGuide block to a barely useful level.

Steps required include:

  • Add the username/password to global config.
  • Retrieve the xml file for the course using curl.
  • Parse the InDesign xml using Moodle.
  • Modify the HTML produced to use that information.
  • Retrieve the file for the name of the module, chapter etc.
  • Generate the HTML for the block based on that content
  • Initially, retrieve the PDF files via normal http connections to where the guides are located (will require user to login again).
  • Replace that with the use of curl.

There’s still an outstanding problem with the naming used in some courses. i.e. those that have an “introduction”.

Add username/password to global config

Fairly simple to add the form elements to the global config – simply edit config_global.html. However, small problem the text elements are giving the following errors

Notice: Undefined property: stdClass::$block_estudy_guide_username in … on line 8

Interesting, there doesn’t seem to be any difference between the use of those variables in the code and the existing one for base_url. The one difference is that base_url already has a manually set value. Surely there should be a way to initialise these to empty?

Ahh, it turns out it’s connected with the level of debug options, had everything turned on for development. Return it to normal levels for live box – no worries.

Retrieve the xml file

All the necessary variables have been calculated, let’s add a function to return the xml file as a variable.

function getXml() {
global $CFG;

// $base_url/YEAR/PERIOD/COURSE/eStudyGuide/COURSE.xml
$url = $CFG->block_estudy_guide_base_url .
$this->content->year . “/” . $this->content->period . “/” .
$this->content->course . “/eStudyGuide/” .
$this->content->course . “.xml”;
$auth = $CFG->block_estudy_guide_username . “:” .
$CFG->block_estudy_guide_password ;

$curl_handle = curl_init();

if ( $curl_handle )
// $fp = fopen(“tmpfile”, “w”);
// Configure curl options
curl_setopt($curl_handle, CURLOPT_URL, $url );
curl_setopt($curl_handle,CURLOPT_USERPWD, $auth);

// get the stuff
$buffer = curl_exec($curl_handle);

return $buffer;

Well that compiles, all I have to do now is figure out how to call it properly. Ahh, $this of course.

Oops, undefined constant CULTOOPT_HTTPAUTH – dyslexic fingers – CURLOPT

Next problem, the base url doesn’t seem to be coming across properly. Ahh, web server error only gives path – the wrong course code. Testing course code doesn’t have a guide for 2092. Yep, that’s working. Now to parse the bugger.

Parse the XML

The first question is exactly what information do I need to get out of the XML file. The file basically gives a summary of the chapters and headings within the study guide. The tag is used for the chapter titles. The original version gets the titles for each chapter from the XML file and displays that next to the number of the chapter. Given the sparse real estate in a Moodle block, the title of the chapter isn’t going to fit. So we don’t need that.

Essentially, all we need to do is count the number of TOClev1 entries in the XML file.

Xmlize uses a collection of nested associative arrays where, at least for some, the key is the tag. So, from one extent should be able to simply count the number of TOClev1 keys.

Ahh, there’s a nice little function traverse_xmlize within Xmlize that displays the array Xmlize produces in a format that is pretty readable. Here’s an example

$xml_[Story][#][Heading1][0][#] = “Contents
” $xml_[Story][#][TOClev1][0][#] = “The auditing and assurance services profession 9
” $xml_[Story][#][TOClev1][1][#] = “Ethics, independence and corporate governance 19
” $xml_[Story][#][TOClev1][2][#] = “The legal liability of auditors 29
” $xml_[Story][#][TOClev1][3][#] = “The financial report audit process 43
” $xml_[Story][#][TOClev1][4][#] = “Planning and evaluating business risk 51
” $xml_[Story][#][TOClev1][5][#] = “Assessing specific business risks and materiality 59
” $xml_[Story][#][TOClev1][6][#] = “Internal control 65
” $xml_[Story][#][TOClev1][7][#] = “Tests of controls 73
” $xml_[Story][#][TOClev1][8][#] = “Substantive tests of transactions and balances 81
” $xml_[Story][#][TOClev1][9][#] = “Audit sampling 97
” $xml_[Story][#][TOClev1][10][#] = “Completion and review 105
” $xml_[Story][#][TOClev1][11][#] = “The auditor’s reporting obligations 111
” $xml_[Story][#][TOClev2][0][#] = “Introduction 9
” $xml_[Story][#][TOClev2][1][#] = “Learning objectives 9

Very helpful. Essentially all I need do is count the number of elements in one of the arrays. How do you count array elements in PHP? Why, the count function of course. That’s easy

print “count is ” . count( $data[‘Story’][‘#’][‘TOClev1’] ) . “

Of course, Rolley was thinking about using the chapter titles in a roll over or some other GUI rubbish. We should probably get the titles after all. So, simple loop through and a bit of RE replacement to get rid of the page number.

$title = $data[‘Story’][‘#’][‘TOClev1’][0][‘#’];
$title = preg_replace( ‘/\s+[0-9]+/’, ”, $title );

Modify the HTML

Well that’s worked. Simple mod of existing for loop with all the above data.

Small problem, the title is being set to “Array”, seems something is going wrong. Also no code in there to get rid of the page number either. Need to look at this.

Ahh, forgot the [‘#’] needed at the end of the array de-reference. You’ve gotta love complicated, large nested associative arrays – maybe there was some benefit of all those years of Perl programming.

And here’s the “proof”, a “working” eStudyGuide block for Moodle – though it still needs a bit of polishing.

Moodle eStudyGuide block

Retrieve the name of the module

Different courses use different titles for the chapters. So far the options include: module, chapter, topic, and week. Need the block to use the appropriate name. Am wondering if the possible options should be part of the global configuration — probably. Can I be bothered? Yes, probably should.

So, add a textarea to the global config and allow those options to be entered – one to a line. Idea will be that the code will split it up into an array and work on that. A simple kludge.

Oops, not so simple. I enter data into the chapter titles and it disappears. Why?

You know it’s getting to be a long day, perhaps past when you should stop coding when you make a mistake like this. They are disappearing because you’re not displaying the variable you are storing them in when you are showing the form.

How do you split a string in PHP into an array? Spoilt for choice. I’ll go with preg_split – like my REs.

Okay, got curl checking for the various files. However, there appears to be some issues with checking to see if the retrieval actually worked. We’re returning straight away with the first title in the config, even though there should be a file for it. When it doubt, try the negation of what you just did – and that worked – ! $buffer

So, this should be a fully working. Time for some tests.

This is why you shouldn’t test. SOCL11056 is a bit different. Not all the files use the file naming format that involves the “module title”. The first one has “introduction”. Bugger. And the old Perl scripts handle it. Will have to see what the deal is there. How did that work?

Ahh, the relied on being able to access the file system. That’s not going to be possible here. That’s going to have to change. Need to talk to some folk about that. Solution can wait.

Serve PDFs with curl

This will be interesting. The problem is that the location of the eStudyGuide PDFs is behind a HTTP basic auth. Student accounts have permission to access the files, however, they will need to login again (having already logged into Moodle). Want to avoid this. One solution to this might be to have the block generate a link that points back to itself or another service. The “other service” uses curl to go through the HTTP auth, get the file and then send it back to the use.

Question: can you generate a URL to access a service provided by a block? This sounds like it might be beyond the scope of a block.

Actually, it might be as simple as putting a “standard” PHP file into the directory for the block and calling it directly from the block. This seems to work. Probably only need to pass the URL as the form element. The getPDF.php file simply takes a URL, checks that it is within the BASE_URL and sends it back to the user’s browser.

That means, I need to figure out how to:

  • send a URL via http appropriately – urlencode probably, maybe not worry about it, at least for now.
  • have the getPDF.php file access the global variables so it can get base_url

Ahh, there’s a whole rigmarole (good value though) setting up a form processing. No time to do that. Will have to leave it there.

BAM into Moodle #8 – finishing the eStudyGuide building block

The last post in this series described the start of a little project to learn more about PHP/Moodle programming in order to get BAM into Moodle. Essentially everything is done, there are two main tasks left:

  • Identify how to “properly” retrieve a file over http in PHP/Moodle and figure out how to use it.
  • Confirm the phpxml is the best way to parse XML in PHP/Moodle and figure out how to use it.

Once those are done, a rudimentary eStudyGuide block will be complete and I’ll have filled in two of the main holes in my knowledge necessary to put BAM into Moodle.

How to retrieve a file over http in PHP/Moodle

What a difference some time makes. I spent a bit of time Tuesday hunting the web and Moodle for information on this. This morning, apparently, it took 5 minutes. curl seems to be the go.

Starting with this curl tutorial – not to mention the examples here

Here’s a list of questions I think I need to answer around the use of curl, and hopefully the answers I’ve found:

  • How do you use curl to get through basic auth?

    CURLAUTH_ANY is a ?constant? that says use any HTTP auth method.

  • How do you set a mime-type on what’s going back to the client?
    The simplest examples simply get the remote file and return it to the browser. If you do this with a non-HTML file there appears to be some issues around the client handling it appropriately.

    One solution I’ve found is to use the CURLOPT_FILE option to save what is returned by curl to the file system. Then use the header and readfile functions to set everything up appropriately i.e.

    header("Content-type: image/jpeg");
    header("Content-Disposition: attachment; filename=imageName.jpg");

    Would imagine you’d have to use some sort of session variable to keep the filename unique and also remember to remove the file.

    Wonder if you can use header without the need for readfile? Yep, the works, use the CURLOPT_RETURNTRANSFER option so that the file is returned as a string and then use the following

    header("Content-type: image/jpeg");
    header("Content-Disposition: attachment; filename=imageName.jpg");
    print $buffer;

    Of course the question now becomes what if you are transferring really large files. Won’t that consume “RAM” for the web server and on a heavily used site cause some “issues”? So maybe the file option is better.

  • What are the necessary checks etc you should do when using curl?
    Seem to be all fairly standard ones, check return values etc, don’t do horrible security stuff. That said, there seems to be some variability within the existing Moodle code that is using curl – some seems to be quite anal about checks.
  • What’s TRUE in php?
    CURLOPT_BINARYTRANSFER needs to be set to TRUE for transferring binary files. What’s the numeric value for TRUE in PHP? Okay, 0 is false. Somewhat familiar.

Parsing XML

Appears, at the moment that the “xmlize” library in Moodle is the simplest method to parse XML. Produces a nested data structure with the content. Pretty similar to what is done at the moment. Is there something better?

Given that parsing XML isn’t a main requirement for BAM, I won’t bother going any further. I think I’ll be using Magpie to parse the RSS that BAM needs to manipulate.

xmlize is simple to use, looks like it is time for lunch. After lunch will be trying to code all this up. I want a working eStudyGuide block by the end of the day.

The design and implementation of Webfuse – Part 3

The following is the last of, what is now, a three part series of blog posts outlining the design and implementation of the Webfuse system. These are part of chapter four of my thesis. The previous two parts are here and here.

The structure of this section is based on the design guidelines developed for Webfuse and outlined in a section in this post. Each of the three posts outlining the design and implementation of Webfuse are using the design guidelines as the structure through which to explain the implementation of Webfuse. This post closes out the implementation by looking at the final two guidlines – be flexible and support diversity, and encourage adoption.

Webfuse will be flexible and support diversity

The aims which flexibility and support for diversity, as outlined in Section 4.3.2, were meant to achieve included enabling a level of academic freedom, being able to handle the continual change seen as inherent in the Web, and providing a platform to enable the design and use of Webfuse to change and respond in response to increased knowledge due to experience and research. It was intende to achieve these aims through a number of guidelines outlined in Section 4.3.2. The following seeks explain how the design and implementation of Webfuse fulfilled these guidelines and subsequently fulfil the stated goals.

Do not specifically support any one educational theory. The design of Webfuse as a web publishing system and integrated online learning environment gave no consideration to educational theory. The design of the functionality offered by the page types was seen to be at a level below educational theory. That is, the four categories of tasks required of a Web-based classroom – information distribution, communication, assessment, and class management – were seen as building blocks that could be used to implement a number of different educational theories. For example, a social constructivist learning theory might use a simple combination of a discussion board and an interactive chat room as the primary tools on the course site. A more information centric or objectivist approach would focus more on the use of the information distribution tools and the quiz tool. In addition, if a strong case was built for providing greater support for a particular educational theory then this could be provided by developing a collection of page types – using COTS products where appropriate – specific to that educational theory. Only those staff interested in using that educational theory would be required to use those page types.

Separation of content and presentation. The separation of content and presentation was achieved through a combination of the page types and the Webfuse styles. As shown in Figure 4.1 and Figure 4.5 it was possible to change the appearance of a Webfuse web page without modifying the content.

Platform independence and standards. This guideline was achieved through an emphasis on the use of platform independent open-source software, the use of the Perl scripting language and active support for compliance with Web standards. Webfuse was written in the Perl scripting language with user interaction occurring via the Webfuse CGI scripts. To run a copy of Webfuse it was necessary to have a web-server, simple relational database, a version of Perl and a small number of other open source products used to implement some of the “micro-kernel” services and page types (e.g. Ewgie required Java). During 1997 two project students successfully ported Webfuse to the Windows platform (Walker, 1997).

Provide the tools not the rules. The main support for this guideline was the absence of any specification of how an online course might be structured. An academic was free to choose the structure and the page types used in the design of the online course. Including simply using the Content page type that would allow them to provide any HTML content. With the development resources available and the widespread novelty of the Web, it was not possible to develop functionality that would enable academics to modify the available styles or write their own page types. However, the design of Webfuse did initially attempt to provide enough flexibility in the presentation of the pages managed by Webfuse to enable students and staff to adapt use of the system to their personal situation. At the time of the development of Webfuse, Internet access for the majority of students was through fairly slow modem access, which was charged on a time basis and made it important to minimise time spent connected (Jones & Buchanan, 1996). To support this goal Webfuse automatically produced three different versions of every page: a text only version, a graphical version and a version using frames. Figure 4.4 shows a graphical version of a page from the original site and near the top of the page it is possible to see navigation links to the three versions of the page. Figure 4.6 is the text only version of the page shown in Figure 4.4.

The Units web page (text version) for M&C for Term 2, 2007

Figure 4.6 – The Units web page (text version) for M&C for Term 2, 2007

Webfuse will seek to encourage adoption

In order to encourage adoption of Webfuse four separate design guidelines were established and described in Section 4.3.2. The following seeks to explain how those guidelines were realised in the implementation of Webfuse.

Consistent interface. The Webfuse authoring interface was implemented through the page update script and supported through the use of page types. The page update script implemented a consistent model and main interface for the authoring process. The page types, working as software wrappers, provided a “Webfuse encapsulation” interface to work within the page update script. Whether using the TextIndex page type or the EwgieChatRoom page type the editing interface behaved in a consistent way. The websites produced by Webfuse also produced a consistent interface through the HTML produced by the page types and the Webfuse styles.
Increased sense of control and ownership. It is unlikely that technology alone could achieve this guideline. Webfuse sought to move towards fulfilling this guideline by providing academics with the ability to control their own course sites where previously this was out of the reach of many. It was also hoped that the flexibility and support for diversity provided by Webfuse would help encourage a sense of ownership.

Minimise new skills. In 1996, the Web was for many people a brand new environment. Any web-publishing tool was going to require the development of new skills. Webfuse sought to minimise this by supporting and enhancing existing practice and by using common institutional terminology. This was achieved through the provision of page types such as Lecture, StudyGuide and Email2WWW that connected with existing practice and enabled it to be taken onto the Web. The page types also allowed for the use of CQU specific terminology in the interface. With the page type’s wrapper capability performing the translation between CQU and COTS product terminology. Lastly, the flexibility of Webfuse as a web publishing system allowed the use of URLs that used CQU specific terminology. The URL for the course site used in Table 4.2 was The components of this URL, including “Academic Programs”, “Units”, “85321” and “mc”, were all common terms used by the members of the M&C community. Not a feature of other e-learning tools.

Automate. As described above Webfuse automatically produced text only and graphical versions of all pages to help those users who required it, to minimse download times. Each of the page types were designed, where possible, to automate tasks that staff or students might have to do manually. For example, the Lecture page type automatically converted Powerpoint slides into individual lecture slides. The LectureSlide page type automatically converted audio into four different format to support the diversity of computer platforms of the time. The StudyGuide page type automatically produced tables of content.


Jones, D., & Buchanan, R. (1996). The design of an integrated online learning environment. Paper presented at the Proceedings of ASCILITE’96, Adelaide.

Walker, M. (1997). Porting Webfuse to the Windows platform. Retrieved 29 July, 2009, from

The design and implementation of Webfuse – Part 2

This post continues the description of the design and implementation of Webfuse started with this post.

Webfuse will be an integrated online learning environment

The idea of Webfuse as an integrated online learning environment encapsulated three main ideas: there would be a consistent, easy-to-use interface; all tools and services would be available via that interface; and that the system would, where possible, automate tasks for the teachers and students. The design of Webfuse as a web publishing system based on hypermedia templates was designed to achieve this goal.

The primary interface for Webfuse was the web. All services provided by Webfuse were managed and accessed through a Web browser. All services were provided by web pages implemented through hypermedia templates. Templates that could, where appropriate, provide additional support by automating tasks (e.g. the Lecture page type described in Table 4.3). The interface to create, modify and manage the websites was provided by the page update process and the hypermedia templates using the same consistent model.

Webfuse will be eclectic, yet integrated

The focus of this requirement was to achieve a system that could be more responsive to changes in requirements and the external context through the inclusion of existing services and tools. The eclectic, yet integrated structure of Webfuse was informed by a combination of concepts including: micro-kernel architecture for operating systems, hypermedia templates, and software wrappers. The following provides more detail of this design and how it was implemented and finishes with a complete listing of the functionality provided by Webfuse in the period from 1996 through 1999.

Micro-kernel architecture

The kernel of an operating system is the part that is mandatory and common to all software, the idea of a micro-kernel is to minimize the kernel in order to enforce a more modular system structure and make the system more flexible and tailorable (Liedtke, 1995). The micro-kernel approach helps meet the need to cope with growing complexity and integrate additional functionality by structuring the operating systems as a modular set of system servers sitting on top of a minimal micro-kernel (Gien, 1990). The micro-kernel should provide higher layers with a minimal set of appropriate abstractions that are flexible enough to allow implementation of arbriatry services and allow exploitation of a wide range of hardware (Liedtke, 1995).

The initial design of Webfuse included the idea of establishing a core “kernel” of abstractions and services relevant to the requirements of web publishing. These abstractions were built on underlying primitives provided by a basic Web server. Continuing the micro-kernel metaphor, the Webfuse page types were the modular set of system servers sitting on top of the minimal micro-kernel. The initial set of Webfuse “kernel” abstractions were implemented as libraries of Perl functions and included:

  • authentication and access control;
    The services of identifying users as who they claimed to be and checking if they were allowed to perform certain operations was seen as a key component of a multi-user web publishing system. The functionality was built on the minimal services provided by web servers and supplemented with institution specific information, for example, the concepts of courses.
  • validation services;
    In the early days of the Web the primitive nature of the publishing tools meant that there was significant need for validation services such as validating that correctness of HTML and the search for missing links.
  • presentation;
    This encapsulated the Webfuse style functionality that allowed the representation of pages to be changed independent of the content.
  • data storage; and
    Content provided by content experts was a key component of the Webfuse publishing model. Page types needed to be able to store, retrieve and manipulate that content in standard ways.
  • page update.
    The page update process was the core of the Webfuse publishing model. It involved how the content experts provided and managed content and how that content was then converted into a web pages. A part of this aspect of the Webfuse architecture was a specification of how the Webfuse page types would communicate and interact.

Hypermedia templates as software wrappers

The simple “TableList” page type discussed above and used to produce the web page shown in Figure 4.1 and the page update form in Figure 4.2 was written entirely by the Webfuse developers. A key aspect of the design of Webfuse was the recognition that there would not be sufficient Webfuse developer time available to allow implementation, from scratch, of all the necessary page types. Especially those page types necessary for more complex functionality, such as synchronous, interactive chat rooms. The idea of implementing hypermedia templates as software wrappers around commercial-off-the-shelf (COTS) software – mostly open source software – was adopted to address this problem.

In software engineering, the term wrapper refers to a type of encapsulation whereby a software component is an encased within an alternative abstraction and it is only through this alternative interface that clients access the services of the wrapped component (Bass et al., 1998, p. 339). A wrapper leaves the existing code of the encapsulated component as is, however, new code is written around it to connect it to a new context (Sneed, 2000). In the case of Webfuse, the hypermedia templates – in the form of Webfuse page types – were used to encapsulate a variety of existing open source software applications and connect them to the Webfuse and CQU context.

Sneed (2000) identifies the introduction of the concept of wrappers with Dietrich, Nackman and Gracer (1989) and its use to re-use legacy applications within an object-oriented framework. Wrappers have also been used in reverse and re-engineering (Sneed, 2000) and security. Wrappers were also one method used by the hypermedia community to integrate complex hypermedia systems with the World-Wide Web (e.g. Bieber, 1998; Gronbaek & Trigg, 1996). Wrappers were also used to integrate third-party applications into open hypermedia systems that emphasize delivery of hypermedia functionality to the applications populating a user’s computing environment (e.g. Whitehead, 1997).

In the case of Webfuse the intent was that the Webfuse wrappers would wrap around commercial-off-the-shelf software (COTS) products, mostly in the form of open-source applications. In the mid to late 1990s there was, in part because of the spiraling cost of custom-developed software, a shift on the part of government from discouraging the use of commercial software to encourage its use (Braun, 1999). Increasingly solutions were built by integrating COTS products rather than building from scratch (Braun, 1999). By 2001, Sommerville (2001, p. 34) describes it as more normal for some sub-systems to be implemented through the purchase and integration of COTS products.

Boehm (1999) identifies four problems with the integration of COTS products: lack of control over functionality and performance; problems with COTS system interoperability; no control over system evolution; and support from COTS vendors. The use of software wrappers to encapsulate COTS products into the CQU context and the general reliance on using open source COTS products was intended to help Webfuse address these issues. Another issue that arises when using a diverse collection of COTS products is the significant increase in the diversity and duplication in the user and management interfaces for each of the COTS products. It was intended that the Webfuse page types, in their role as software wrappers, would also be designed to provide Webfuse users with a consistent user interface. A user interface, where possible, which made use of CQU terms and labels rather than those of the COTS product.

Harnessing hypermedia templates, software wrappers and COTS products allowed Webfuse to combine the benefits of hypermedia templates – simplified authoring process, increased reuse, and reduced costs (Catlin et al., 1991; Nanard et al., 1998) – with the benefits of the COTS approach – shorter development schedules and reduced development, maintenance, training and infrastructure costs (Braun, 1999). While the use of open source COTS products provided access to source code and removed the influence of a commercial vendor (Gerlich, 1998), it did increase the level of technical skills required.

One example of the type of COTS product included into Webfuse through the use of software wrappers is the MHonArc email to HTML converter (Hood, 2007). As mentioned previously M&C courses were already making increasing use of Internet mailing lists as a form of class communication. An obvious added service that Webfuse could provide was a searchable, web-based archive of these mailing lists for use by both staff and students. Rather than develop this functionality from scratch a Email2WWW page type was written as a wrapper around MHonArc. The Email2WWW page type also integrated with the Webfuse styles system to enable automatic modification of appearance and was connected with the mailing list system used at CQU and so was able to regularly and automatically update the web-based archives of course mailing lists.


The complete functionality provided by Webfuse is a combination of the services provided by the Webfuse “micro-kernel” (described above) and the functionality implemented in each of the available Webfuse page types. This section seeks to provide a summary of the functionality available in the Webfuse page types as at the end of 1999 – the end of this action research cycle. The initial collection of page types was designed on the basis of the four major tasks required of a Web-based classroom identified in McCormack and Jones (1997, p. 367): information distribution, communication, assessment, and class management.

The original purpose of the Web was to enable the distribution and access to research information, which means that the Web can be extremely useful for the distribution of information (McCormack & Jones, 1997, p. 13). By the end of 1999 Webfuse had a collection of 11 page types providing information distribution related services. Table 4.3 provides a summary of these page types, their purpose and what, if any, COTS products the page types used for implementation of their purpose. The FAQ page, like a number of other page types, was written by a project student (Bytheway, 1997).

Table 4.3 – Webfuse information distribution related page types – 1999
Page Type COTS Product Purpose
Lecture, Lecture Slide Webify (Ward, 2000) for Postscript conversion to slides.
SoX (SoX, 2009) for conversion of audio into various formats
raencoder (RealNetworks, 1996) for audio conversion into Real Audio format
Convert Postscript file of a lecture (usually generated by Powerpoint) into an integrated collection of lecture slides. Each lecture slide could have audio converted into any one of four available formats.
Study guide, STudy guide chapter None Conversion of a study guide into chapters of online material broken up into individual pages, single chapter print versions and the production of table of contents and index
PersonContent, PersonDetails None Display information about teaching staff
FAQ (Bytheway, 1997) None Creation and management of lists of frequently asked questions
Content None Enable simple management of HTML content
File upload None Allow most people to upload files to the web site
TableList, Index, ContentIndex None Provide mechanisms to create index and associated child nodes in a hierarchical web structure
Search htdig ((The ht://Dig group, 2005) Search content of site

Communication is an essential part of the learning experience and a task for which the Web offers a number of advantages and supports through a number of forms (McCormack & Jones, 1997, p. 15). Table 4.4 provides a summary of the five different communication related page types provide by Webfuse by the end of 1999. This list of page types illustrates two points: there are fuzzy boundaries and overlap between these categories and the Webfuse eclectic, yet integrated structure meant it was possible to have multiple page types performing similar roles.

The FormMail page type listed in Table 4.4 could be used as a form of communication but was generally used to perform surveys that could fit under the Assessment category below. Table 4.4 also shows that there were two page types providing web-based discussion boards. Within a few years a third would be added. Each additional discussion board was added as it improved upon the previous functionality. However, it was not necessary to remove the other previous discussion boards and there were instances where this was useful as some authors preferred the functionality of the older versions.

Table 4.4 – Webfuse communication related page types – 1999
Page Type COTS Product Purpose
EwgieChat Ewgie (Hughes, 1996) An itneracitve chat-room and shared whiteboard system
WWWBoard WWWBoard (Wright, 2000) Web-based asyncrhonous discussion board
WebBBS WebBBS (AWSD, 2009) Web-based asyncrhonous discussion board
Email2WWW MHonArc (Hood, 2007) Searchable, web-based archives of mailing list disussions
FormMail FormMail (Wright, 2002) HTML form to email gateway, implementation of surveys

Assessment is an important part of every course, it is essential for knowing how well students are progressing (student assessment) and also for being aware how well the method of instruction is succeeding (evaluation) (McCormack & Jones, 1997, p. 233). Table 4.5 provides a summary of the four Webfuse page types associated with assessment that were in place by the end of 1999. Two of these page types (online quiz and assignment submission) are connected with student assessment, while the other two (UnitFeedback and Barometer) are associated with evaluation. The FormMail page type mentioned in Table 4.4 was also primarily used for evaluation purposes and is somewhat related to the far more CQU specific UnitFeedback page.

Table 4.5 – Webfuse assessment related page types – 1999
Page Type COTS Product Purpose
Online quiz None Management and delivery of online quizzes – multiple choice and short answer
Assignment submission None Submission and management of student assignments
UnitFeedback None Allow paper-based CQU course survey to be applied via the Web
Barometer No software, but concept based on idea from Svensson et al (1999) Allow students to provide informal feedback during a course

Class management involves the clerical, administrative and miscellaneous support tasks necessary to ensure that a learning experience operates efficiently (McCormack & Jones, 1997, p. 289). Table 4.6 summarises the three Webfuse page types associated with class management by the end of 1999. There is some overlap between this category and that of assessment in terms of the management and marking of student assignments.

Table 4.6 – Webfuse class management related page types – 1999
Page Type COTS Product Purpose
Results management None Allows the display and sharing of student progress and results
Student tracking Follow (Nottingham, 1997) Session analysis of student visits to course web pages
TimetableGenerator None Allow students and staff to generate a personalised timetable of face-to-face class sessions


AWSD. (2009). WebBBS.   Retrieved 29 July, 2009, from

Bass, L., Clements, P., & Kazman, R. (1998). Software Architecture in Practice. Boston: Addison-Wesley.

Bieber, M. (1998). Hypertext and web engineering. Paper presented at the Ninth ACM Conference on Hypertext and Hypermedia, Pittsburgh, Pennsylvania.

Boehm, B. (1999). COTS integration: plug and pray? IEEE Computer, 32(1), 135-138.

Braun, C. L. (1999). A lifecycle process for the effective reuse of commercial off-the-shelf (COTS) software. Paper presented at the 1999 Symposium on Software Reusability, Los Angeles.

Bytheway, S. (1997). FAQ Project Report.   Retrieved 29 July, 2009, from

Catlin, K., Garret, L. N., & Launhardt, J. (1991). Hypermedia Templates: An Author’s Tool. Paper presented at the Proceedings of Hypertext’91.

Dietrich, W. C., Nackman, L. R., & Gracer, F. (1989). Saving legacy with objects. Paper presented at the Object-oriented programming systems, languages and applications, New Orleans, Louisiana.

Gerlich, R. (1998). Lessons Learned by Use of (C)OTS. Paper presented at the 1998 Data Systems in Aerospace, Athens, Greece.

Gien, M. (1990). Micro-kernel architecture: Key to modern operating systems design. UNIX Review, 8(11).

Gronbaek, K., & Trigg, R. (1996). Toward a Dexter-based model for open hypermedia: unifying embedded references and link objects. Paper presented at the Seventh ACM Conference on Hypertext, Bethesda, Maryland.

Hood, E. (2007). MHonArc: A mail-to-HTML converter.   Retrieved 10 January, 2008, 2007, from

Hughes, K. (1996). EWGIE – Easy Web Group Interaction Enabler.   Retrieved 29 July, 2009, from

Liedtke, J. (1995). On micro-kernel construction. Operating Systems Review, 29(5), 237-250.

McCormack, C., & Jones, D. (1997). Building a Web-Based Education System. New York: John Wiley & Sons.

Nanard, M., Nanard, J., & Kahn, P. (1998). Pushing Reuse in Hypermedia Design: Golden Rules, Design Patterns and Constructive Templates. Paper presented at the Proceedings of the 9th ACM Conference on Hypertext and Hypermedia.

Nottingham, M. (1997). Follow 1.5.1.   Retrieved 29 July, 2009, from

RealNetworks. (1996). Release notes: RealAudio encoder 2.0 for UNIX.   Retrieved 29 July, 2009, from

Sneed, H. (2000). Encapsulation of legacy software: A technique for reusing legacy software components. Annals of Software Engineering, 9(1-4), 293-313.

Sommerville, I. (2001). Software Engineering (6th ed.): Addison-Wesley.

SoX. (2009). SoX – Sound eXchange – Home page.   Retrieved 29 July, 2009, from

Svensson, L., Andersson, R., Gadd, M., & Johnsson, A. (1999). Course-Barometer: Compensating for the loss of informal feedback in distance education. Paper presented at the EdMedia’99, Seattle, Washington.

The ht://Dig group. (2005). ht://Dig – Internet search engine software.   Retrieved 29 July, 2009, from

Ward, S. (2000). Webify: Build web presentations from postscript.   Retrieved 29 July, 2009, from

Whitehead, E. J. (1997). An architectural model for application integration in open hypermedia environments. Paper presented at the Eighth ACM Conference on Hypertext, Southhampton, UK.

Wright, M. (2000). WWWBoard.   Retrieved 29 July, 2009, from

Wright, M. (2002). FormMail.   Retrieved 29 July, 2009, from

The design and implementation of Webfuse – Part 1

This continues the collection of content that goes into Chapter 4 of my PhD thesis. Chapter 4 is meant to tell the story of the first iteration of Webfuse from 1996 through 1999. The last section I posted describes the design guidelines that informed the implementation of Webfuse. This post and at least one following post seeks to describe the details of the design and implementation of Webfuse.

As with all the previous posts of content from the thesis, this content is in a rough first draft form. It will need more work. Comments and suggestions are more than welcome.

Design, implementation and support

This section outlines how the design guidelines for Webfuse introduced in the previous section (Section 4.3.2) were turned into a specific system design and how that system was implemented and supported during the period from 1996 through 1999. First it briefly outlines the process, people and technology used during this period to design and implement Webfuse. It then explains how the abstractions that form the design of Webfuse were intended to fulfil the design guidelines introduced in Section 4.3.2. Lastly, it offers a description of the functionality offered by Webfuse towards the end of 1999. The next section (Section 4.3.4) will provide an overview of using Webfuse from both a student and academic staff member perspective.

Process, People and Technology

The initial design and implementation of Webfuse occurred over a period of about 12 months starting in mid-1996. The author performed most of the initial design and implementation work with additional assistance from a small number of project students who worked on particular components. In 1997, Webfuse was taken over by the Faculty of Informatics and Communication. The Faculty appointed a full-time Webmaster and used Webfuse for their faculty website and online learning. The Faculty webmaster helped staff use Webfuse, did some development and was supported by a small number of other Faculty technical staff. The development processes used Webfuse functionality during this period were fairly ad hoc.

From 1996 through 1999, Webfuse was implemented primarily as a collection of Perl CGI scripts and various support libraries and tools. The Perl scripting language was chosen because it was platform independent and scripting languages like Perl allowed rapid development of application via the gluing together of existing application and development was 5 to 10 times faster than through the use of traditional systems programming languages (Ousterhoust, 1998). An Apache web server served the Webfuse CGI scripts and the resulting web pages. For information storage, Webfuse used the file system and a variety of relational databases. All of the applications used in Webfuse were open source. During this the available open source relational databases were not full-featured, the lack of a full-feature relational database influenced some design decisions.

The design

The set of abstractions and decisions that underpin in the initial design of Webfuse drew on a number of existing concepts from the operating systems, information systems and hypermedia communities. The informing concepts included hypermedia templates (Catlin, Garret, & Launhardt, 1991), software wrappers (Bass, Clements, & Kazman, 1998, p. 339), micro-kernel architectures of operating systems (Liedtke, 1995) and known limitations of the World-Wide Web and its hypermedia model (Bieber, Vitali, Ashman, Balasubramanian, & Oinas-Kukkonen, 1997). The design was informed by the understanding of these concepts and the desire to fulfil the five broad design guidelines outlined in Section 4.3.2. The following links these guidelines to the informing concepts and explains the design of Webfuse.

A web publishing tool

From the start Webfuse was seen as a web-publishing tool. The implication of this is that Webfuse was seen as a system that produced web pages and web sites. In particular, Webfuse was intended to manage the website of the Faculty of Applied Science which includes a range of different departments and would be managed by a number of different people. There were a number of known problems with the authoring process of websites at this point in time. The authoring process was usually carried out without a defined process, lacked suitable tool support, and did little to separate content, structure and appearance (Coda, Ghezzi, Vigna, & Garzotoo, 1998). The process also made limited reuse of previous work (Rossi, Lyardet, & Schwabe, 1999) and required better group access mechanisms and online editing tools (K. Andrews, 1996).

The difficulty of authoring on the Web makes it difficult to create and maintain large websites and often the management of such content was, at this stage, assigned to one person or group who became the bottleneck for maintenance (Thimbleby, 1997). This is especially troubling when Nielsen (1997) suggested that rule of thumb that the annual maintenance budget for a website should be at least 50 percent, and preferably the same as, the initial cost of building the site. The nature of learning and teaching and its reliance on communication and collaboration suggested that for e-learning such a recommendation might need to be increased.

The World-Wide Web, at this stage, was a particularly primitive hypermedia system where the lack of functionality made the authoring process more difficult (Gregor et al., 1999). One recognition of this was that a key part of the problem definition outlined in Section 4.2.2 was the difficult and time-consuming nature of web-based learning. It was also recognised that ease of use was a key part of encouraging adoption amongst academic staff. To address this problem it was decided that Webfuse would make use of the concept of hypermedia templates (Catlin et al., 1991; Nanard, Nanard, & Kahn, 1998).

Hypermedia templates (Catlin et al., 1991) are an approach to simplifying the authoring process while still ensuring the application of good information design principles. Hypermedia templates would enable content experts to become responsible for maintaining Websites and thus increases ownership, decreases costs and addresses the authoring bottleneck problem (Jones, 1999b). Hypermedia templates also aid in reuse which is a strategic tool for reducing the cost and improving the quality of hypermedia design and development (Nanard et al., 1998). There initial purpose was to improve the application of information design principles to hypermedia collections (Catlin et al., 1991).

In their initial development hypermedia templates were sets of pre-linked documents that contain both content and formatting information used by authors to create a new set of information (Catlin et al., 1991). The intent was that graphic designers would create the templates, which would subsequently be used by content experts to place material into hypermedia (Catlin et al., 1991). The content experts would not need to become experts in information design, nor would the graphic designers need to become content experts. Editing a template did not require learning any new software or knowledge.

Nanard, Nanard and Kahn (1998) extended the idea into constructive templates with the intent of extending reuse in hypermedia design beyond information and software component reuse into the capture and reuse of design experience. A constructive template is a generic specification which makes it easier for a developer to build a hypermedia structure and populate it with its data (Nanard et al., 1998). While a model describes a structure, a constructive template helps produces instances of that structure by mapping source data into a hypertext structure (Nanard et al., 1998). Template-based hypermedia generation can be implemented using either programming or declarative means. Constructive templates are built on the principle of separating source data from hypermedia presentation and enables work on the structure to be done independently from the content, reducing the burden of production. Through automating large parts of the production process constructive templates drastically reduce cost (Nanard et al., 1998).

As a web-publishing system the primary output of Webfuse was web pages. Each Web page was of a specific type. The type of page specified which Webfuse hypermedia template, during this period they were called page types, would be used to produce the web page. A page type was implemented as a collection of pre-defined Perl functions that would obtain the necessary content from the author, convert that content into the HTML necessary to display the body of the page and carry out any additional necessary steps. Figure 4.1 is an example of a web page produced by Webfuse.

Content index page example

Figure 4.1 – A simple web page produced by Webfuse

On each web page produced by Webfuse there will be an “Edit” link. If an authorised person clicks on this link they are presented by a web form – called a page update form – that allows them to provide, edit and modify the content used to produce the web page. The structure and features of the page update form, as well as the conversion process applied to the content, is unique to the page type.

Figure 4.2 shows the page update form for the web page from Figure 4.1. A page type called TableList produces the web page shown in Figure 4.1. As the name suggests this page type is used to manage a series of lists containing individual elements, which are displayed in a series of separate tables. Each element in the list points to another web page that is created and then managed through Webfuse. In Figure 4.1 there is one list called “Years” which consists of the elements “2008” and “2009”. Figure 4.2 contains HTML form elements to manage two lists. One for the existing list called “Years” and one that can be used to add a new list. As well as managing the elements of lists the form in Figure 4.2 also provides some formatting options including how to sort the list elements, how many columns to have in the table and how big the table borders should be.

Page update form for content index page

Figure 4.2 – Page update form for the web page shown in Figure 4.1

The design of Webfuse as a web publishing system made it necessary to include into the Webfuse an abstraction for the websites it would manage. Such an abstraction was necessary in order to implement the services and interfaces Webfuse would provide to authors to manage their websites. Hypermedia and hypertext, of which the World-Wide Web is an example, have been defined on the basis of their support for non-linear traversal and navigation through a maze of interactive, linked, multiple format information (Kotze, 1998). The “disorientation problem” – getting “lost in hyperspace” – refers to the greater potential for the use to become lost or disoriented within a large hypertext network (Conklin, 1987).

The topology or structure of a hypertext directly affects navigation performance (McDonald & Stevenson, 1996). Oliver, Herrington and Omari (R. Oliver, Herrington, & Omari, 1999) identifies three main structures within hypermedia environments: linear, hierarchical and non-linear or networked. Shin, Schallert and Savenye (1994) suggests that the most popular structure for hypertext and hierarchical and network (non-linear) structures. Garzotto, Paolini and Schwabe (1993, p. 8) point to the observation of many authors that hierarchies are very useful to help user orientation when navigating in a hypertext. Advantages of hierarchies include: a strong notion of place; documents have clear superior/inferior relationships that are sometimes augmented with linear precedence relationships between nodes; they are familiar due to their use in other domains; and the rigidity, which creates some inflexibility, aids comprehension (Durand & Kahn, 1999). Hierarchical structures have also been recommended as the most appropriate structures for large websites (Sano, 1996).

The previous paragraphs draw on research literature to identify a number of advantages to justify the selection of a hierarchical structure for the model of a website use by Webfuse. There were, however, also two pragmatic reasons for this choice of structure. The open source relational databases that were available at the time and used in the implementation of Webfuse were not capable of storing amount and type of data that a large website would require. The use of a relational database to store information was limited to authentication and authorization data. For the most part, the storage of content to be used in generating web pages were stored on the file system of the computer hosting the Web server. The file systems of computers did and continue to use a hierarchical structure of directories and files. Having the website structure used by Webfuse match the structure used to store the information considerably simplified implementation.

Figure 4.3 is a partial, graphical representation of the hierarchical structure of the Faculty of Applied Science website created and managed via Webfuse during 1997. At the top level is the main science home page. The next level down has five main sections including one for the Faculty’s research centre’s and one for each of its four departments – Maths and Computing, Applied Physics, Biology and Chemistry. Each of the department websites followed a similar structure with main sections for information, staff, academic programs, students, research and community. The websites for individual courses – prior to 1998 these were called units – are all contained in their own folders with names based on the course codes (e.g. 85321, Systems Administration).

Partial hierarchy of pages - 1997

Figure 4.3 – A partial hierarchy of the Faculty of Applied Science website in 1997

Each of the boxes shown in Figure 4.3 represents an individual web tree but also represents a collection of related material. The “Units” box represents the “Units” web page (Figure 4.4) and the folder “Units” that contains all of the web sites for the units offered by the Department of Mathematics and Computing in the second term of 2007. By default all Webfuse pages are freely available to anyone on the Web. There is an access control facility that can optionally restrict access to specific people or groups.

The Webfuse access control system does not make any distinction between types of accounts; there is not concept of a course designer, administrator, or student account in Webfuse (McCormack & Jones, 1997, p. 365). Each user account belongs to a number of groups. Groups can be assigned permissions to perform certain operations on Webfuse objects, which are either individual web pages or entire websites. The directory path that specifies where the object resides on the web server is used to uniquely identify each object. Initially, there were three valid operations that could be performed on an object (McCormack & Jones, 1997, p. 366):

  • access;
    The ability to access or view the page. By default all objects are able to be viewed by anyone on the web.
  • update; and
    The ability to modify the page using the page update process.
  • all.
    The ability to perform any and all operations on the object.

Home page for M&C in 1997

Figure 4.4 – The Units web page for M&C for Term 2, 2007

Some page types recognise additional operations that are specific to the operation of the page. For example, an early assignment management page type recognised a “mark assignment” operation (McCormack & Jones, 1997).

Table 4.2 provides an example of two different Webfuse permissions. One which gives permission for members of the group “jones” to perform all operations on the entire website for the unit 85321, Systems Administration. Another which gives permission to edit just the home page for the 85321 website. An object that ends with a slash (/) indicates everything within that directory while an object without the slash at the end indicates just that web page.

Table 4.3 – Example Webfuse permissions
  Modify 85321 Web site Modify 85321 Web page
Object /mc/Academic_Programs/Units/85321/ /mc/Academic_Programs/Units/85321
Operation All update
Group jonesd jonesd

A Perl script, called the page update script, included a check of the permissions system to determine if a particular person could edit the requested page. The page update script was also responsible for identifying the type of page being edited, accessing the appropriate code for the page type and adding other information and services to the page update form. Other services available on the page update form fall into two main categories:

  1. Webfuse services; and
    A number of support services such as HTML validation, link checking, access control, file management and hit counters could be accessed via the page update form.
  2. Page characteristics.
    As well as the content managed by the page type each web page also contained a number of the characteristics including the page type, title, colours used and the style template.

The notion of a style or style template was used to further separate the appearance of a page from the content. This enabled the appearance of the same page, containing the same content to evolve over time for whatever reason (this feature was added before the concept of cascading style sheets – CSS – was widely used). Figure 4.5 is the same web page as shown in Figure 4.1, however, it is using a 1998 style for the Faculty of Informatics and Communication. This was done by editing the page, changing the style template and updating the page.

Content Index page example

Figure 4.5 – Guides web page (Figure 4.1) with a different style


Andrews, K. (1996). Position paper for the workshop, Hypermedia Research and the World-Wide Web. Paper presented at the Applying Hypermedia Research to the World-Wide Web, Hypertext’96.

Bass, L., Clements, P., & Kazman, R. (1998). Software Architecture in Practice. Boston: Addison-Wesley.

Bieber, M., Vitali, F., Ashman, H., Balasubramanian, V., & Oinas-Kukkonen, H. (1997). Fourth Generation Hypermedia: Some Missing Links for the World-Wide Web. International Journal of Human-Computer Studies, 47, 31-65.

Catlin, K., Garret, L. N., & Launhardt, J. (1991). Hypermedia Templates: An Author’s Tool. Paper presented at the Proceedings of Hypertext’91.

Coda, F., Ghezzi, C., Vigna, G., & Garzotoo, F. (1998). Toward a Software Engineering Approach to Web Site Development. Paper presented at the 9th International Workshop on Software Specification and Design, Isobe, Japan.

Conklin, E. J. (1987). Hypertext: An introduction and survey. IEEE Computer, 20, 17-41.

Durand, D., & Kahn, P. (1999). MAPA: a system for inducing and visualizing hierarchy in websites. Paper presented at the Hypertext’98, Pittsburg, PA.

Garzotto, F., Paolini, P., & Schwabe, D. (1993). HDM – A model-based approach to hypertext application design. ACM Transactions on Information Systems, 11(1), 1-26.

Gregor, S., Jones, D., Lynch, T., & Plummer, A. A. (1999). Web information systems development: some neglected aspects. Paper presented at the Proceedings of the International Business Association Conference, Cancun, Mexico.

Jones, D. (1999). Webfuse: An integrated, eclectic web authoring tool. Paper presented at the Proceedings of EdMedia’99, World Conference on Educational Multimedia, Hypermedia & Telecommunications, Seattle.

Kotze, P. (1998). Why the hypermedia model is inadequate for computer-based instruction. Paper presented at the Sixth Annual Conference on the Teaching of Computing and the 3rd Annual Conference on Integrating Technology into Computer Science Education, Dublin City University, Ireland.

Liedtke, J. (1995). On micro-kernel construction. Operating Systems Review, 29(5), 237-250.

McCormack, C., & Jones, D. (1997). Building a Web-Based Education System. New York: John Wiley & Sons.

McDonald, S., & Stevenson, R. (1996). Disorientation in hypertext: the effects of three text structures on navigation performance. Applied Ergonomics, 27(1), 61-68.

Nanard, M., Nanard, J., & Kahn, P. (1998). Pushing Reuse in Hypermedia Design: Golden Rules, Design Patterns and Constructive Templates. Paper presented at the Proceedings of the 9th ACM Conference on Hypertext and Hypermedia.

Nielsen, J. (1997). Top ten mistakes of web management.   Retrieved 27 July, 2009, from

Oliver, R., Herrington, J., & Omari, A. (1999). Creating effective instructional materials for the World Wide Web. Paper presented at the AUSWEB’96, Gold Coast, Australia.

Ousterhoust, J. (1998). Scripting: Higher Level Programming for the 21st Century. IEEE Computer, 31(3), 23-30.

Rossi, G., Lyardet, F., & Schwabe, D. (1999). Developing Hypermedia Applications with Methods and Patterns. ACM Computing Surveys, 31(4es).

Sano, D. (1996). Designing large scale web sites. New York: John Wiley & Sons.

Shin, E. C., Schallert, D. L., & Savenye, W. C. (1994). Effect of learner control, advisement, and prior knowledge on young students’ learning in a hypertext environment. Educational Technology, Research and Development, 42(1), 33-46.

Thimbleby, H. (1997). Gentler: A Tool for Systematic Web Authoring. International Journal of Human-Computer Studies, 47, 139-168.

BAM into Moodle #7 – an eStudyGuide block

The last post provided an overview of what is required to put BAM into Moodle and generated a list of things I have to learn in order to implement it.

This post will tell at least some of the story of developing my first CQU Moodle block. Whether the block ever gets used in action, is beside the point. The main aim is to give me the opportunity to engage in a bit of constructionism. In particular, the block I’ve decided to have a crack at will help me learn answers to the following questions developed at the end of the last post.

  • In Moodle/PHP, how do you retrieve remote documents over HTTP? Is there a LWP::Simple equivalent?
  • In Moodle/PHP, how do you parse XML?

Introducing the eStudyGuide block

CQU has a history that includes a significant investment in print-based distance education (“The institution” section in this post offers some background). That means that this year there are at least 10,500 students enrolled at CQU studying by distance education. For many of those students the primary scaffolding of their study, which occurs off-campus, is a study guide. A print based guide written by CQU staff that summarises what they should read and do each week.

For the last couple of years CDDU has been working on a variety of innovations around these study guides. Including developing a process that produces better quality versions of study guide in both hard copy and online. Some work has been done to integrate the online study guides with the VLEs used by CQU. However, the institution has now adopted Moodle and while there is a level of integration, it’s not great.

The aim here is to develop a Moodle block (an eStudyGuide block) that allows the online version of a CQU study guide to be added to a course.

Strictly speaking the online study guide should be included in the main guts of the course home page, not as a block. But the aim here is learn more while producing something reasonably useful, without wasting too much time.


The eStudyGuide block will display a bit of HTML that will provide a list of links to each module/chapter of the study guide. The PDFs of the study guide will be stored on a remote web server. When the block is added to the course site it will need to:

  • Identify the course, period and year associated with the current course.
    I believe that CQU currently uses the format

    for Moodle courses. This translates into the Term 2, 2009 offering of the course COIS20025.

  • Formulate the URL of the folder containing the e-study guide.
    This will be
  • Check that the folder/URL exists.
  • Retrieve and parse the XML file that details the study guide.
    The XML file is produced by InDesign, the publishing system used to generate the guides. It contains information such as the number of chapters/modules, the names of the files, the titles of each module/chapter etc.

    The XML file will be protected by Basic AUTH so it will need to authenticate before getting the XML file.

  • Generate a list of links to each module/chapter.
    Initially these will be just straight URLs.

The development process

The following tells the story of the process I used to put the block together, it may not be complete, but includes the following steps:

  • Create a dummy eStudyGuide block that generates dummy HTML. DONE
  • Add in a global configuration for the block for the BASE_URL for the files. DONE
  • Get it to parse the CQU Moodle course format and use the new URL in the static HTML generated. DONE
  • Get it to retrieve the XML file.
  • Get it to parse the XML file.
  • Dynamically generate the HTML.

Getting a dummy eStudyGuide block

BAM into Moodle post #5 details some of the mechanics for this process and it in turn draws heavily on this page on the Moodle site

The process goes something like this:

  • Create the dummy block_estudy_guide.html file using the template on the Moodle site.
  • Login to Moodle, click on notifications, dummy estudy_guide up and going, eStudyGuide block added to course
  • No need to add configure options for the block, in real life the block will get the course code from some variables, there’s nothing to configure.
  • Add a specialization function to set the title.
    Eventually the title will include the course code, which is set from variables. To set the title this way we need the specialization function. Set this to a constant for now. Will replace this with the real course code in a later stage.
  • Add in the global configuration data.
    In this case the BASE_URL for the location of the eStudyGuides on the external website. Needs a file with the HTML/form for the configuration, at this stage BASE_URL. Done: config is even saving from action to action.

    Had some trouble using the global configuration data in the instance, turned out I needed the


    PHP statement to bring the


    variable into scope.

  • Create HTML guide links
    Going to do this by creating a hard coded associative array and a for loop. The idea being is that eventually the parsed XML will replace the hard coding.
  • Convert to using block_list – not done for now
    Moodle’s block abstraction includes a special case where the block is used to display a list. Where each item has it’s own image. I don’t have easy access to an image set. Addition: Talk to Rolley about the idea of a specific image.

Parse the CQU course format

The task here is to get the Moodle course ID/code, assume it’s in CQU format and parse it into it’s constitute parts.

  • Where is the course variable?
    I’m assuming this is a global variable which is discussed here in the Moodle programming course. Ahh, there’s a global $COURSE with

    being the Moodle ID, but there’s also entries for fullname, shortname. Assume id.

  • Modify the block to use this in the title.
    Ahh, id is the unique number id. What about shortname? That seems to be the one. At least until further confirmation.

    Need to look at REs etc in PHP. Okay, that’s over. Difficult getting use to the slightly new approaches.

  • Parse the format and stick in content variables – done.

Retrieving the XML file

Now the interesting stuff.

  • Get the full path format for the XML file
    Currently it’s BASE_URL/Guides/YEAR/PERIOD/COURSE/eStudyGuide/COURSE.xml
  • Find out how to retrieve files over HTTP within Moodle/PHP
    Well, using xref it’s possible to see within lib phpxml – probably useful for XML parsing. Couldn’t see anything else useful.

    Looking through existing modules might be useful. There’s a flickr module that uses a class called RSSCache – which looks very interesting. Which is included as part of the magpie RSS parser. This came with the default install of Moodle – so one problem solved for the broader BAM project.

And that’s where I have to leave it. Haven’t found the retrieval mechanism. But once I have it, should be straight forward.

BAM into Moodle #6 – Planning and some real coding

The previous post in this series started me along the lines of actually coding something in Moodle. It was only a pretend thing but indicated that blocks are fairly simple to implement. That previous post also pondered about the need to do some planning. Which brings me to the two main tasks for today

  1. Put some rough planning down on “paper”.
    I still don’t know enough about Moodle and its model to get into detailed planning. This planning will be a rough outline of the major tasks that need to be done to give me a heads up.
  2. Start some real coding.
    I need to develop my PHP/Moodle skills and real life tasks are the best way to do this – isn’t this in keeping with the social constructionism (or is that constructivism) at the heart of Moodle – so I’m looking for useful blocks I can produce that help me develop the skills I need for BAM.

Big up front design

Traditional software projects love to promote their rationality through their use of Big Up Front Design (BUFD). i.e. they gather all the requirements, analyse all the tasks and then come up with the perfect design. At this stage they can pass the design over to the lowly technicians who will implement the design.

Far from being rational, I’m a strong believer from both a theoretical and practice perspective, that BUFD is irrational, it’s plan stupid, even insane. It doesn’t have any basis in the cognition of people nor the nature of complex systems. It’s an approach that is certain to fail.

So anyone looking for BUFD (and there will be a few) in this project is going to be disappointed. Actually, there’s a chance some might be pleased, because for them the absence of BUFD will indicate that I’m “cowboy” coding, that I’m not being rational.

To put it simply, I don’t know enough about Moodle to engage in BUFD. I doubt there is anyone at my current institution who knows enough about Moodle, BAM and how academics might like to use BAM. The aim of the next bit of planning is to allow me to identify the necessary tasks I need to undertake to increase my level of understanding. So, that at within the last steps of the project, I’ll be able to develop a BUFD.

For a related perspective, have to love Dilbert (click on the cartoon to see a version you can read).


Some “planning” points

  • BAM will not be part of the Moodle assignment system, it will integrate with it.
    Currently, BAM is used mostly for assignments. Students post to their blogs in order to be marked and receive feedback. However, BAM is not a part of the assignment submission system at CQU. It does integrate with that system, but it’s not part of it. I plan to continue this approach.
  • One Moodle module with many activities
    My current assumption is that I’ll be able to implement a single Moodle module that will be able to provide each of the activities required to implement BAM. I suspect this will be possible, given Moodle’s strong modular nature, but I don’t know for certain.
  • The main BAM activities
    The following are a summary of the main activities that users will perform with BAM
    • Configure BAM for a course – Coordinator
      The first step in using BAM is configuring it. This requires the coordinator to provide the following information:
      • Can students register their blog?
      • Should the student blogs be mirrored?
      • For each question the students have to respond to: question title, question body. Addition: include some dates about when the question should be answered??
    • Register blog with BAM – student
      Having created a blog, the student provides a copy of their blog URL to BAM. BAM checks that it can find an RSS feed associated with that blog and also that the student hasn’t made some common mistakes (e.g. registered the WordPress home page/blog, rather than their individual blog)
    • Check progress – student
      Visiting this page allows the student to check their progress with BAM on two fronts. First, what posts from their blog has BAM matched with the required questions (Addition: maybe a good idea for BAM to show the questions). Second, they can see the marks and comments made by the markers. (Addition: would be nice for the marks/comments to be able to be posted back to the students blog as comments – perhaps a step too far at the moment.
    • Check progress – staff
      Staff can see a page that lists all of their students and gives an indication of if they’ve registered their blogs, how many entries, when the last post was and a link to the live blog.
    • Check student posts – staff
      Similar to the above, but this one gives an overview of all the required questions and the status of the student’s responses to those questions. This is the main starting place for the marking process.
    • Mark a student post – staff
      Usually linked to from the previous page (Addition: would be good to provide a cooked RSS feed of student posts for markers. Each cooked item could include a link back to the mark a post activity. Would allow markers to use an RSS reader to keep up with student posts and then mark them from there)
    • Mirror blog entries – cron
      At a configured time interval visit each the RSS feed for each individual student blog and, if updated save a new copy of the RSS feed on the Moodle server.
    • Modify student blog feed/posts – staff member
      While BAM tries to match student posts to the required questions, it doesn’t always work. This interface is for the marker to handle these problems. Essentially displays a list of all the student posts and whether or not they have been allocated to a question. Allows the marker to “de-allocate” a post or allocate it as the answer to a question.
    • Manage marking – coordinator
      The coordinator of a course, based on CQU practice, needs to be able to manage if and when marks/comments are returned to the student. Depending on how Moodle works, the coordinator may also need to be able to manage which staff are marking which students. Personally, I’d like to avoid doing this.
    • Integrate with assignments – coordinator
      Provide some form of control/management over how the data within BAM is integrated with assignments in Moodle.

Functionality uncertainty

The following is an attempt to take the major user activities listed above and summarise the major functionality required to implement these as currently used in the Webfuse version of BAM. The point is that I probably don’t know how to implement this functionality in Moodle/PHP or if it can be implemented. i.e. it’s the stuff I need to learn.

  • Configure BAM for a course
    This will be a fairly standard web application. Present a form, allow the user to modify the form, store the data in a database. I don’t see this being all that difficult. Probably a good place to start with BAM coding.
  • Register blog with BAM
    Fairly standard web application, however, once the blog URL is inserted/changed there are some additional tasks including:
    • Is the URL valid?
    • Does it exist? Can it be retrieved?
    • Does it have an attached RSS/Atom feed?
      In Perl this is done using LWP::Simple to retrieve the file and XML::Feed to check the resulting file to see if it has an attached feed and to discover what the URL for that feed is.
  • Check progress – student
    A simple web application, given the student’s details, retrieve information from the database and display it for the student.
  • Check progress – staff
    Same as the above
  • Check student posts
    Same as the above
  • Mark a student post
    Same as the above
  • Mirror blog entries
    This is perhaps the most difficult one. It goes through each student blog in courses that are currently being mirrored and
    • Compares the feed against the one saved on disk. If no change, stop now. Otherwise
    • Parse the XML of the feed into internal data structures
    • Look through all the posts in the feed looking for new ones.
    • Compare each new post against the unanswered questions, if there’s a match stick details in the marking database, ready for the marker.
  • Modify student blog posts/answers
    This one is also difficult as it shares a need to parse XML with Mirror and needs to compare that with the data in the database. Needs the XML parsing functionality.
  • Manage marking – coordinator
    Fairly straight forward web application. Need to identify if there are already ways in Moodle for storing this information.
  • Integrate with assignments
    Currently, this is essentially
    • Apply a formula to translate marks for each answer to a single mark result.
    • Copy that result to the assignment system database table.

    Need to find out how this works (the assignment database) in Moodle.

Where to know?

Some specific technical questions to answer

  • In Moodle/PHP, how do you retrieve remote documents over HTTP? Is there a LWP::Simple equivalent?
  • In Moodle/PHP, how do you parse XML?
  • Can a Moodle module support multiple activities?
  • How does “integration” with the Moodle assignment system work?
  • Exactly how do you code up a fairly standard database-backed web app/form in Moodle/PHP?

Have to come up with projects that let me learn the answers to those questions.