Depending on the number of slots allocated to Moodle and the quality of the applicants, I’m planning to run 2 projects this year.

SCORM 2004 – building on the work from our GSOC 2011 student Mayank, I’d like to get some more progress towards SCORM 2004 compliance – there are a large number of tasks to complete 2004 and I may take on more than one student to work on this (depending on slots/applicants) If you know of any students good with Javascript and PHP – make sure you point them towards GSOC.

Improving Plagiarism API – The plagiarism api currently only hooks into the upload assignment types – I’ve been planning to add hooks into other Moodle modules but haven’t quite got round to it – this project will involve adding new hooks to other Moodle modules and probably some work on some plagiarism plugins like Crot.

For more info see: http://docs.moodle.org/dev/Projects_for_new_developers

Ever since Moodle 1.5 I’ve enjoyed developing the Turnitin integration which has resulted in the new Plagiarism API in Moodle 2 – now we have plugins for Urkund, Crot, Moss and hopefully more to come!

I started developing the Turntin integration while working for Lincoln University and playing with the Turnitin basic assignment type developed by Turnitin which didn’t really suit our requirements. Since then a company called nLearning (now part of Turnitin) developed a 3rd plugin called “Moodle Direct” – so there are now 3 different ways of connecting Moodle to Turnitin.

Independently developing the Turnitin plugin has presented a range of challenges – including:

•  Keeping in touch with new features/improvements to Turnitin services and implementing them in my plugin.
• Providing support to people who have downloaded the plugin and have a contract with Turnitin but no support contract with me – I’ve spent a lot of volunteer time helping via e-mail/forum support but this can be quite time-consuming. It can also be confusing for people using the plugins – not knowing who to contact related to a problem.
• Diagnosing issues can prove difficult – is there an issue with the code/Turnitin (Kudos to the Turnitin Devs who have provided a lot of support directly to me while developing/improving the plugin)
• Enabling my plugin can be a convoluted process, emails to Turnitin, extra configuration required…

Where am I going with this you ask? – Turnitin are working directly with me to “merge” their “Turnitin Direct” plugin with my plagiarism plugin for Moodle 2.x – this will bring a range of very good benefits.

• Single support base – support for the plugins will come direct from Turnitin for all plugins making it much easier to access support.
• Larger feature-set available – my focus has been on the originality checking feature – Turnitin provides a range of other features which will be implemented and supported in both plugins.
• Moodle admins will be able to choose between using the plagiarism plugin which uses the existing assignment types or to use a separate “turnitin” module.
• The new plugin will be backwards compatible with data stored from my version. (planning to use the same tables)
• The new plugin will sync grades entered via Grademark with Moodle.
• The new plugin will support the existing featureset (and more).

Obviously there will be some form of changeover period where I will continue some level of support for the existing plugin but sites will be migrating to the newer version provided directly from Turnitin – Turnitin are hoping to provide the new code in a git repo and allow others to contribute patches back (I know I’ll probably be submitting a few in the long term)

This is all very new and there isn’t a specific time frame in place to have this completed except to say that you should keep an eye out for the initial code release in the upcoming months.

Thanks to everyone who has tested/provided feedback/provided patches/provided funding for the plugin – it’s been a cool project to be involved with. Now that the core plugin will be supported directly from Turnitin I may finally have time to implement the plagiarism api into other areas of the Moodle codebase like forum posts, workshop mod, Essay quiz questions etc – or maybe I’ll just waste away more time on SCORM…

The 2.0 version has the following features:

• Single folder for really easy installation – just drop it into a new folder called “turnitin” in the new /plagiarism folder in 2.0
• Uses Teachers own credentials instead of a “global teacher” account – makes for better integration with Turnitins other products like Grademark
• I mentioned it above – new “experimental” integration with Grademark. (needs a few victims to test/give me feedback)
• Better Date handling – uses the start/close dates in Moodle as the start/close dates in the Turnitin assignments it creates (although Turnitin doesn’t like start/close dates before the assignment is created so it uses the earliest possible date instead)
• More advanced setting of Turnitin features when creating/updating an assignment. You can now set:
  • Whether to compare a submission against other students files
  • Whether to compare a submission against Internet sources
  • Whether to compare a submission against Journals, periodicals, publications
  • When to generate the Originality Reports
  • Whether to use an institutional repository (if set up)
  • Exclude Bibliograpy references from the report
  • Exclude quoted text from the report
  • Exclude small matches from the report
• Improved performance and handling of errors (still more improvements to come over the next week on the error reporting page)
• Now creates assignment in Turnitin as soon as Moodle assignment is created instead of waiting for the first file to be submitted (it creates the assignment in Turnitin when the next cron cycle runs after the Moodle assignment is created)
• Easier integration with other Moodle modules (soon to come) – keep an eye out for integration with essay quiz questions and the Workshop module.

The new Moodle 1.9 version has the following new features:

• Better Date handling – uses the start/close dates in Moodle as the start/close dates in the Turnitin assignments it creates (although Turnitin doesn’t like start/close dates before the assignment is created so it uses the earliest possible date instead)
• More advanced setting of Turnitin features when creating/updating an assignment. You can now set:
  • Whether to compare a submission against other students files
  • Whether to compare a submission against Internet sources
  • Whether to compare a submission against Journals, periodicals, publications
  • When to generate the Originality Reports
  • Whether to use an institutional repository (if set up)
• Improved performance and handling of errors

Sites using an older 1.9 version of the integration that wish to upgrade to Moodle 2.0 must upgrade their 1.9 Turnitin integration first – otherwise they will lose content/data during upgrade.

The new 1.9 version of the code is available as a git branch here:
http://github.com/danmarsden/moodle19-patch_turnitin
(this is based off the old mdl19-turnitin branch on git.catalyst.net.nz so if you’ve been using that it should be an easy switch)
Installation of this on an existing 1.9 site should only be attempted if you can easily manage significant customisations to your Moodle site (and know how to use git) – if this is new/difficult for you, best that you wait untill you upgrade to Moodle 2.0 – you can also get this code in patch or diff format here:
http://github.com/danmarsden/moodle19-patch_turnitin/compare/MOODLE_19_STABLE…mdl19-turnitin.diff
http://github.com/danmarsden/moodle19-patch_turnitin/compare/MOODLE_19_STABLE…mdl19-turnitin.patch

The 2.0 version of the code is available as a git branch here:
http://github.com/danmarsden/moodle-plagiarism_turnitin
or you can get it as a zip here:
http://github.com/danmarsden/moodle-plagiarism_turnitin/zipball/master

To install the 2.0 version – just grab the files above and put them in a new folder called “turnitin” under the /plagiarism folder in 2.0
then..

1. Go to: Admin > Advanced features and select the checkbox “Enable plagiarism plugins” and save the settings
2. Go to: Admin > Plugins > Plagiarism Prevention > Turnitin configure this page as usual
3. Select the “Turnitin Defaults” tab and set the default settings you would like when a new module that allows plagiarism is created.
4. Make sure Scheduled Tasks/Cron is running on your site
5. Create a new Assignment and make sure Turnitin is enabled
6. Submit a file
7. Done!

I’m also working with Sergey Butakov to generate a Moodle 2.0 Crot plagiarism plugin – Crot is an open source based plagiarism tool that uses the MS Live (Bing) Search engine as a backend for comparing results – it’s not quite ready/working yet, but you can check out the progress so far here:
http://github.com/danmarsden/moodle-plagiarism_crot

For those wanting to create their own Plagiarism plugin with another tool, I’ve created a “new” template that can be used as a basis for creating your own plugin here:

http://github.com/danmarsden/moodle-plagiarism_new

and developer docs on the api are available here:
http://docs.moodle.org/en/Development:Plagiarism_API

It’s important to note that Moodle 2.0 doesn’t include any Plagiarism plugins by default – you must install them separately – but as it is all self-contained in a folder it is very easy to install. Inclusion of Plagiarism Plugins in Moodle Core may be investigated/debated/discussed in future (definitely not before 2.0 final release!)

Always keen to hear feedback – let me know how you go!

• Improved display of errors to both Students and Teachers -  errors in the 1000 series are now printed directly to the screen instead of just displaying the error code to teachers.
• A new option to the advanced assignment type has been added to allow teachers to choose when the files are submitted to turnitin – before or after a student has submitted the files for marking. (thanks to Darren Harkness from Athabasca for this patch!)
• 419 error codes were occurring for older assignments due to a bug that has been fixed
• 407 error codes were occurring due to the API calls happening too fast for the Turnitin API to catch up
• 31 error codes were occurring due to files being deleted before submission to Turnitin – a check for file existence was shifted to address this.
• new css class added to similarity links to allow better control in css
• improved error checking and debugging information to various areas.
• A bug with the logic checking for closed activities has been fixed

Hope that’s useful for some people! – I’ve also been talking with the Crot block authors this past week – I’m hoping there’s a way we can integrate the crot and turnitin work so that they are both available via a similar interface!

3 March 09 Edit: looks like I introduced a bug with the single upload assignment type in this last change – should be fixed now!

MDL-7206 – a patch to allow all assignments to be downloaded in a single zip
This is something I wrote a while back that has been hacked at by various people and a patch in that issues is available for 1.9 – I’ve wanted to get this into core for a while, but haven’t ever got round to it!

Some issues around error handling in backups – silient backups/restores dont’ do any error reporting, so I’m planning on modifying the backup_logs table to allow other errors to be saved other than just data related to scheduled backups.  details on this are in MDL-14736 and MDL-12037

I’d also like to prepare a patch for a new backup/restore type that would allow a restore to update a course, rather than duplicating or needing to delete the content of the course first – it would be nice to see this feature integrated into an improved backup/restore UI to allow a teacher to select each individual activity/resource and decide whether to update/delete/roll dates forward etc.

And then theres the Turnitn stuff I’d like to get into core, although it will require some funding so I can convert the code to work with the new stuff in 2.0

• it presented a different interface which did not use the Site’s Moodle Theme (although it kept the Moodle header in a frame at the top of the page)
• All the files were stored on Turnitins servers, so if an institution cancelled their subscription to turnitin there was no easy way of retrieving and storing the submitted files against specific users/courses/assignment
• It required manual editing of config files for account Id’s, secret keys, api addresses, emails etc.

So…. I started hacking on an integration that allowed teachers to use the standard Moodle modules – such as the advanced and single assignment types with an extra setting that allowed them to “enable” turnitin for “this” assignment. It’s taken a lot of constant refining (and there’s still more to go) but we now have a patch that works pretty well for 1.9 (and a 1.6 patch too!)

The development on this patch was initially done in my own time, but more recently has been funded by the University of Waikato, with Sussex University funding the 1.6 patch!

This past couple of weeks, Waikato have paid for some improvements to the error reporting – it now displays nicer error messages to the students and staff when a file has been submitted that Turnitin Cannot process – like errors around submitting images instead of text documents.

One of the issues with the integration is that it uses a single “global Teacher account” – every assignment/course/file is connected to that single “Teacher” in the Turnitin system. I did this initially as the turnitin system only allows 1 teacher to be assigned to a course, and as Moodle allows multiple teachers, we needed to share a common teacher account. But! – this means that if we were to login as that teacher on the turnitin.com site, we would have access to all assignments created by the Moodle integration. This isn’t suitable for people using the Turnitin Grademark tool, or to allow teachers easy access to the extended featureset available on the turnitin.com site. I’d like to modify this to use a single teacher account for each course inside moodle, to allow better access.

There are currently a couple of issues around the Turnitin API that the Turnitin dev team tell me they would like to fix!

• There’s currently no easy way for a teacher to use the Turnitin grading interface (grademark has some fancy features which the Moodle gradebook doesn’t!) and then have those grades sent back into the Moodle Gradebook – The Turnitin guys tell me they’re keen to implement this (not sure on a timeframe) – it’s advantageous to them as people only using the Moodle integration may not want to pay for Grademark if it doesn’t integrate with Moodle.
• The standard Turnitin interface allows a teacher to elect whether turnitin will store the submitted assignments in their main database for comparison against other submitted papers. This option isn’t available as part of the api, but it is an option that a lot of people I have talked to would like to have.

Another thing that bugs me a bit about the integration in it’s current form is the method used to munge e-mail addresses when institutions don’t want their students to be able to access the turnitin.com site directly. all this currently does is add some text to the start of their e-mail address which is fine if the students cannot alter their e-mail address and use an internal organisation address, but if they can use gmail/yahoo accounts then the “munge” introduces a range of issues.

I added the “munge” feature because the Integration creates valid assignments/courses on the turnitin.com site, and if a student went directly to the turnitin.com site and submitted an assignment, there would be no record of that submission in Moodle – which would potentially cause confusion for teachers! – so the munge was added to prevent that from being happen.

A “better way” to manage this would be for the Turnitin API to allow assignments to be created that do not allow manual submission from the turnitin.com site…… I must remember to ask the turnitin team about this……

My thanks goes out to all the people who are using the integration and helping others “trying” to use it in the moodle.org forums – I get a lot of e-mail these days, and am constantly chasing my tail trying to respond to it all, so that help is really appreciated!

We do need some funding to do a lot of this work (including the work to create a 2.0 version of the integration and put it in Moodle Core) – let me know if this is something you might be able to help fund!