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

References

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.

Process

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.

References

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.

Solutions?

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.

References

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_CONNECTTIMEOUT,2);
curl_setopt($curl_handle,CURLOPT_RETURNTRANSFER,1);
curl_setopt($curl_handle,CULTOPT_HTTPAUTH,CURLAUTH_ANY);
curl_setopt($curl_handle,CURLOPT_USERPWD, $auth);

// get the stuff
$buffer = curl_exec($curl_handle);
curl_close($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?
     curl_setopt($curl_handle,CULTOPT_HTTPAUTH,CURLAUTH_ANY);
    curl_setopt($curl_handle,CURLOPT_USERPWD,'username:password');

    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");
    readfile("tmpfile");

    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 science.cqu.edu.au 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 http://science.cqu.edu.au/mc/Academic_Programs/Units/85321/. 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.

References

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 http://web.archive.org/web/19981205071012/webfuse.cqu.edu.au/People/Developers/Matthew_Walker/

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.

Functionality

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

References

AWSD. (2009). WebBBS.   Retrieved 29 July, 2009, from http://awsd.com/scripts/webbbs/

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 http://web.archive.org/web/19990503041438/webfuse.cqu.edu.au/People/Developers/Scott_Bytheway/Report/index.html

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 http://www.mhonarc.org/

Hughes, K. (1996). EWGIE – Easy Web Group Interaction Enabler.   Retrieved 29 July, 2009, from http://www.alts.net/Java/Ewgie/docs/

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 http://www.mnot.net/follow/README

RealNetworks. (1996). Release notes: RealAudio encoder 2.0 for UNIX.   Retrieved 29 July, 2009, from http://service.real.com/help/encoder/unix2.0/how_to.html

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 http://sox.sourceforge.net/

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 http://www.htdig.org/

Ward, S. (2000). Webify: Build web presentations from postscript.   Retrieved 29 July, 2009, from http://www.fnal.gov/docs/products/webify/webifydoc/

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 http://www.scriptarchive.com/wwwboard.html

Wright, M. (2002). FormMail.   Retrieved 29 July, 2009, from http://www.scriptarchive.com/formmail.html