MoodleDocs - User contributions [en]

Development:Obsolete - Moodle forms library

2007-02-01T22:28:17Z

Pramette: /* Exaples of converting existing Moodle forms */

'''This was a proposal for discussion - you can see info about the development of the formslib [[Development:lib/formslib.php|here]]'''.

The OU has developed quite a nice in-house library to simplify creating Moodle editing forms. We would like to contribute it back to the community, and then as part of the accessibility work we are comissioning, get all Moodle forms modified to use it. However, before we can contribute it back, we need to get consensus withing the community that it is right for Moodle, and we need to tidy up the code a bit.

This document outlines how the library should work after cleaning up, so the community can see whether they like it, and OU developers know what is involved in the cleanup.

==What the system will be capable of==

The library allows developers to create editing forms by creating a high-level representation of the form as a data-structure in memory, configuring all necessary options, and setting initial values of fields, and then the library generates the actual HTML of the form to include in the page.

We are not planning to change significantly the way that Moodle editing forms look and function. However, by putting all the HTML (and JavaScript, CSS, ...) generation in one place, we make it much easier to make systematic improvements to accessibility, usability, client-side validation, etc. in future. Indeed, the OU's code already generates HTML that is a bit more accessible that most Moodle forms.

By allowing developers to think at a higher level, we make their life easier, in the same way that datalib saves them from worrying about the details of SQL most of the time.

The general way the library will work is that it will assume sensible defaults for everything to reduce the amount that has to be typed. So for a lot of input fields, you will only have to specify

# the field type (e.g. text, think <input type="" ... />, However the hope would be to move towards higher-level types, such as integer, path, url, as in require_param, etc.)
# the field name (think <input name="" ... />).

Everything else that is needed will be derived from these using sensible defaults. We need label text? We'll look up the field name in the lang file (each form will specify which lang file to use). We need a help link? Well, use /lang/en_utf8/help$langfile/$name.html. We need a field size? Each type will have a sensible default.

However, if you want to override any of these defaults, you can by setting that option explicitly. Because there will be lots of options, and normally you will only need to change a few, the library will use a named attribute style, so example code would look like:

<pre>
$field = new text_field('fieldname');
$field->set_set('size', 30);
$field->set_set('label', 'lablestring');

// or

$field = new text_field('fieldname');
$field->set_set(array('size' => 30, 'label' => 'lablestring'));

// or

$field = new text_field('fieldname', array(
'size' => 30,
'label' => 'lablestring'
));
</pre>

In this example, 'lablestring' would again get looked up in the lang file automatically.

For this situation, where there are lots of options available, but most people only need to change a few, I think this style of API works better than PHP function calls with lots of optional parameters. The options available for each field type will be documented in the comment where that class is defined.

The library is designed to make it easy to add new field types, or new options to existing field types. Indeed, that is how the library has evolved so far: a bit at a time as needed.

New field types are just new PHP classes, and they are likely to be subclasses of a base class that only change a few things. They don't even have to be defined in the central form library. If you need an specialist field type only within one (e.g. contrib) module, you can create a new field-type subclass in that module code and use it in that modules forms without having to touch core code. And if we later want to move that field type into core, it is trivial to move the class definition.

Since we will have to tidy up the code anyway, all the function/class/method/option names in the API are potentially changable.

==PHP API==

Each thing in the API will be a PHP class, these basically fall into three categories: the whole form, groupings of form fields, and individual field types. Note that the groupings are currently only used for functional reasons, like showing or hiding groups of elements. Logical groupings, that would correspond to <fieldset> tags for accessibility, are not included yet, but could be added.

I am just going to list all the possible method calls. I will assume that it is clear what they do from their names (and I am running out of time).

===The whole form===

There is a class to represent a form, and most of the time you will be able to do everything you want to do by calling methods on this class, and you don't have to worry about the rest of the API.

$mf = new moodle_form($langfile);

$field = &$mf->add($fieldtype, $fieldname, $fieldoptions, $insertbefore);
$field = &$mf->add_item($fieldobject, $insertbefore); // $insertbefore is optional. By default things are inserted at the end of the form.
$field = &$mf->remove($fieldname);
$field = &$mf->get($fieldname);

These let you add or remove things from the form. The field you have just done stuff to is returned, but most of the time you will not bother to do anything with the return value. These method work with groups, etc. not just fields.

$mf->set_action($url);
$mf->set_init_html_editor(); // There was a reason why the library can't guess this from the list of fields.
$mf->set_submit_caption($langstringid);
$mf->set_hidden($fieldname, $value);
$mf->set_value($fieldname, $value); // The initial value for this field. (or use the $form attribute on show()).
$mf->set_error($fieldname, $message); // Error message to be displayed in red next to this field if you are doing server-side validation.

$mf->show($action, $form);

Show the form. $form is an object holding the default value of each field that has not already been set using set_value().

$mf->add_xhtml($htmlphpcode, $insertbefore);
$mf->set_xhtml_param($name, $value);

You can insert arbitrary bits of HTML of PHP code into the forum using this. When outputting the form, the library does '''eval('?>'.$htmlphpcode.'<?php ');''' in a place where $form is in scope, and the variables passed in via set_xhtml_param are available from an array as $xmlform[$name].

$new_mf = moodle_form::loadfile($xmlfilename);
$new_mf = moodle_form::loadstring($xmlstring);

Create a whole form using the XML syntax mentioned below.

===Fields===

The library also has classes representing the different field types, which you can use if you want.

$field = new xxxx_field($name, $options_array); // where xxxx is one of the field types below.
$field->set($optionname, $optionvalue);
$field->set($optionarray); // Array of $optionname => $optionvalue pairs.
$optionvalue = $field->get($optionname);

$field->set_value($value); // Sets the initial value of this field.

$field->output($form); // Print this form element.

Normally you won't call output() directly. You will call $mf->output, which will call $field->output on each field for you, but you can use this yourself if you just want to print one form control anywhere you like, not as part of a form.

===Groups===

Groups (which will probably get renamed to conditionalshow, but I don't want to change all the examples just now) allow you to show or hide a collection of fields, depending on the setting of another field.

groups have basically the same methods as fields, but $name is optional. $name has no function, unless you need to identify the group later for a call the $mf->get($groupname);

There are a few extra methods they have over fields:

$field = &$group->add($fieldtype, $fieldname, $fieldoptions, $insertbefore);
$field = &$group->add_item($fieldobject, $insertbefore);
$field = &$group->remove($fieldname);
$field = &$group->get($fieldname);

$group->set_condition($conditionfield, $conditionvalue);

The elements within the group will only be visible when the field $conditionfield elsewhere in the form has value $conditionvalue. This works best when $conditionfield is a dropdown.

Do we also want a conditionalenable group that enables/disables a bunch of fields, rather than showing or hiding them?

===Multiples===

This lets you do things like enter multiple usernames, as in the 'working example' below. You would also use it on the editing form for multiple choice questions, to enter any number of answers with matching grades.

Again, they support the same methods as fields, and also:

$field = &$multiple->add($fieldtype, $fieldname, $fieldoptions, $insertbefore);
$field = &$multiple->add_item($fieldobject, $insertbefore);
$field = &$multiple->remove($fieldname);
$field = &$multiple->get($fieldname);

$multiple->set_max($number);

For accessibility reasons, multiples work by printing a certain number of copies into the HTML, and these are then shown or hidden by the JavaScript. This is for accessibility reasons, and so the forms work without JavaScript. max is the number of copies that are printed. It defaults to 10.

==Field types initially supported==

All field will support the options:

'''lable''' the field lable. This is a string that is looked up in the language file. Or, if the string starts with an '=' character, then this is trimmed off, and the rest of the string is used literally. Defaults to name.

'''help''' the name of the help file to link to. Defaults to name. Setting to '' removes the help icon.

'''helpalt''' the langstring to use for the tooltip of the help icon.

'''optional''' if set to 'yes', then adds a checkbox before the field to enable or diable it. The checkbox's name is name is constructed by taking the field name and appending 'enable'. If you want another name, set this option to the checkbox name, instead of 'yes'.

'''needcapability''' this is mainly aimed at 1.7 roles and permissions. Will hide this field unless the user has the named capability. At first, this will only recognise the values admin, teacher, student, noneditingteacher, guest, and translate these into the obvious isadmin() type calls.

More options will probably get added in future.

===display===

Just diplay a value with a label, the value can't be edited.

===text===

Text input box.

Supports the additional options:

'''required''' a regexp that is used for client-side validation against that regexp.

'''size''' as in <input size="" ... />

===file===

File upload box.

===date===

Date, like quiz open and close dates.

===html===

The standard HTML editor, or just a text area, depending on the settings. (This calls print_textarea).

===dropdown===

A dropdown menu. This field has the additional methods:

$dropdown->add_option($value, $label);
$dropdown->remove_option($value);

$label is optional. By default: if $value is an integer, use that integer as the label, otherwise look $value up in the langfile.

Dropdown supports the additional option:

'''default''' which option to select by default.

===radio===

A set of linked radio buttons, which are defined in the same way as dropdown menu options.

===multiselect===

A list box where you can select multiple options, which are defined in the same way as dropdown menu options.

Actually, I think we should change the implementation of this to use a set of checkboxes when there are fewer than about a dozen options, and automatically switch to useing a list box when there are more than that. And maybe add an optional parameter to force the listbox/checkbox decision one way or the other.

===yesno===

A dropdown menu with just the two options 'yes' and 'no'.

===user===

A flashy text box where you can enter user's names, and it does AJAX stuff to help you auto-complete them.

===visible===

This generates the standard "Visible to students" field that appears on add/update module forms.

===groupmode===

This generates the standard "Group mode" field that appears on add/update module forms.

==XML form definition format==

This provides the quickest way to create most forms. It should be clear how this translates into the PHP API calls defined above. XML elements $mf->add() calls. XML attributes correspond either to required information, or to set_opt calls. Form filds, like dropdowns, that need extra information get it from child elements. See the examples below for what it looks like.

==A working example==

Here is an example of a form produced with the current (un-cleaned-up) version of the OU's library. The form looks like this:

[[Image:Formproposal_Add_newsfeed_form.png]]

There is some OU-specific stuff here, like presentation and authids, and the fact that we reveal $user->username to teachers. I am assuming you can filter that out.

More interestingly, notice that

* The required field Name has not been filled it, so its label is red, and the create button is disabled. Below, you will see that anything typed into this field will actually be validated against a regular expression.
* The user field type does cool AJAX to save you typing the whole name.
* After you have added one user as a poster, a second box appeared where we could type a second user name. And when we finish typing here, a third box will appear.

The XML defining the form looks like this:

<pre>
<editform langfile='block_newsfeed'>
<text name='location'/>
<text name='name' required='\S'/>
<text name='pres' required='^([0-9]{2}[a-zA-Z]?)?$'/>
<html name='summary'/>
<dropdown name='type'>
<option value='internal'>type_internal</option>
<option value='external'>type_external</option>
</dropdown >
<group requiredname="type" requiredvalue="external">
<item type='text' name='url'/>
</group>
<group requiredname="type" requiredvalue="internal">
<date name='startdate'/>
<dropdown name='public'>
<option value='1'>access_public</option>
<option value='0'>access_private</option>
</dropdown >
<text name='defaultauthid'/>
<multiple>
<text name='optionalauthids' required='^([A-Z0-9]+)?$'/>
</multiple>
<multiple>
<user name='posters'/>
</multiple>
<multiple>
<user name='approvers'/>
</multiple>
</group>
</editform>
</pre>

The PHP code that creates the form definition ($xf), and the object with all the current values ($form) and sets all the default values looks like this:

<pre>
$xf=xml_form::load_file('editfeed.xml');
$xf->set_init_html_editor(true);
$form=new stdClass;
$newsfeedid=optional_param('newsfeedid',0,PARAM_INT);
if($newsfeedid) {
$nf=feed_system::$inst->get_feed($newsfeedid);
$form->location=$nf->get_folder()->get_path();
$xf->set_hidden('newsfeedid',$newsfeedid);

$form->name=$nf->get_name();
$form->pres=$nf->get_pres();
if($form->pres==null) {
$form->pres='';
}
$form->summary=$nf->get_summary();
if(is_a($nf,'external_news_feed')) {
$form->type='external';
$form->url=$form->get_url();
} else {
$form->type='internal';
$form->startdate=$nf->get_start_date();
$form->public=$nf->is_public();
$form->defaultauthid=$nf->get_default_authid();
xml_form::set_multiple($form,'optionalauthids',$nf->get_optional_authids());
xml_form::set_multiple($form,'posters',$nf->get_poster_usernames());
xml_form::set_multiple($form,'approvers',$nf->get_approver_usernames());
$form->newsfeedid=$newsfeedid;
}

} else {
$folderid=required_param('folderid',PARAM_INT);
$lf=feed_system::$inst->get_location_folder($folderid,null);
$nf=null;
$xf->set_submit_caption(get_string('create'));
$form->location=$lf->get_path();
$xf->set_hidden('newsfeedid',0);
}

// ... print_header and other boring bits.

print_simple_box_start('center');
$xf->show(basename(__FILE__), $form);
print_simple_box_end();
</pre>

==Examples of converting existing Moodle forms==

These are four example forms that Marting Dougiamas asked to see how we would handle.

===Add resource -> Link to a file or web site===

[[Image:Formproposal_Add link resource.png]]

I have taken the liberty of changing the way the window options work on this form. Instead of having a show/hide window settings button, and when that is turned on showing all the options for both same window and new window, I have changed it to be a same window/popup window dropdown, and depending on the setting there, showing or hiding the particular set of options. It would also be possible to use the library to generate the existing form.

This form contains some very specific bits, namely the location field and the parameters sections. For now I have kept the existing code to generate these bits. If fields like the location field were used in other places, we could add a url field type. I don't see any future in generalising the parameters bit, though the code to generate it could be cleaned up. I just copied and pasted the existing code, and made the minimal changes.

I've used a multiselect for the window options. That will require a small change to the response processing code.

<pre>
$mf = moodle_form::loadstring('
<editform langfile="resource">
<text name="name" help=""/>
<htmlarea name="summary"/>
<xhtml label="location"><![CDATA[
echo "<input type=\"text\" name=\"reference\" size=\"90\" value=\"$form->reference\" alt=\"reference\" /><br />";
button_to_popup_window ("/files/index.php?id=$form->course&choose=form.reference", "coursefiles", $xmlform['strchooseafile'], 500, 750, $xmlform['strchooseafile']);
echo "<input type=\"button\" name=\"searchbutton\" value=\"$xmlform['strsearch'] ...\" ".
"onclick=\"return window.open('$CFG->resource_websearch', 'websearch', 'menubar=1,location=1,directories=1,toolbar=1,scrollbars,resizable,width=800,height=600');\" />\n";
if ($CFG->resource_allowlocalfiles) {
button_to_popup_window ("/mod/resource/type/file/localfile.php?choose=form.reference",
"localfiles", get_string('localfilechoose', 'resource'), 400, 600,
get_string('localfilechoose', 'resource'));
}
]]></xhtml>
<url name="location" showuploadbutton="1" showsearchbutton="1" help=""/>
<dropdown name="windowpopup">
<option value='0'>pagewindow</option>
<option value='1'>newwindow</option>
</dropdown>
<group requiredname="newwindow" requiredvalue="0">
<hidden name="hframepage" value="0"/>
<multiselect name="framepage" help="">
<option value="1">frameifpossible</option>
</multiselect>
</group>
<group requiredname="newwindow" requiredvalue="1">
<multiselect name="windowoptions">
</multiselect>
<integer name="resource_popupwidth" label="resource_popupwidth"/>
<integer name="resource_popupheight" label="resource_popupheight"/>
</group>
<yesno name="parameters"/>
<group requiredname="newwindow" requiredvalue="1">
<xhtml><![CDATA[
<table align="center">

<tr>
<td align="center"><?php print_string("parameter", "resource") ?></td>
<td align="center"><?php print_string("variablename", "resource") ?></td>
</tr>

<?php

for ($i=0; $i < $xmlform['maxparameters']; $i++) {
echo "<tr>\n";
echo "<td valign=\"top\">\n";
echo "<select name=\"parameter$i\">\n";
echo "<option value=\"-\">-- ".get_string('chooseparameter', 'resource')." --</option>\n";
foreach ($xmlform['parameters'] as $field=>$fieldarr) {
if ($fieldarr['value'] === "optgroup") {
echo "<optgroup label=\"{$fieldarr['langstr']}\">\n";
} elseif ($fieldarr['value'] === "/optgroup") {
echo "</optgroup>\n";
} else {
echo "<option value=\"$field\"";
if ($xmlform['alltextfield'][$i]['parameter'] == $field) {
echo " selected=\"selected\"";
}
echo ">{$fieldarr['langstr']}</option>\n";
}
}
echo "</select>\n";
echo "</td>\n";
echo "<td valign=\"top\">\n";
echo "<input type=\"text\" name=\"parse$i\" value=\"{$xmlform['alltextfield'][$i]['parse']}\" alt=\"parameter$i\"/>\n";
echo "</td>\n";
echo "</tr>\n";
}

?>
</table>
]]></xhtml>
</group>
')
$mf->set_xhtml_param('strchooseafile', get_string(...));
$mf->set_xhtml_param('strsearch', get_string(...));

$mf->set_xhtml_param('maxparameters', $this->maxparameters);
$mf->set_xhtml_param('parameters', $this->parameters);
$mf->set_xhtml_param('alltextfield', $alltextfield); // Assuming that this code is after the end of setup() in mod\resource\type\file\resource.class.php

$winopt = $mf->get('windowoptions');
foreach ($RESOURCE_WINDOW_OPTIONS as $optionname) {
$defaultvalue = "resource_popup$optionname";
$form->$optionname = $CFG->$defaultvalue;
if ($optionname != 'height' && $optionname != 'width') {
$winopt->add_option($optionname, "str$optionname");
}
}
</pre>

===Add quiz===

[[Image:Formproposal_Add quiz form.png]]

To convert this form, we need to do something special for the "students may review" bit. You could either invent an new <optiongrid> type, which would be quite easy to implement. That is the option used below. Alternatively, you could use the feature for including arbitrary HTML and PHP in the form, and keep the existing code for generating this part of the form. Since the existing layout breaks when you make the browser window narrow, as in the screenshot, I would be inclined to redo it.

<pre>
$mf = moodle_form::loadstring('
<editform langfile="quiz" help="">
<text name="name"/>
<htmlarea name="introduction"/>
<date name="available" label="quizopen" optional="yes"/>
<date name="due" label="quizclose" optional="yes"/>
<real name="timelimit" lableafter="minutes" helpalt="quiztimer" optional="yes"/>
<dropdown name="questionsperpage">
<option value='0'>unlimited</option>

</dropdown>
<yesno name="shufflequestions"/>



<optiongrid name="reviewoptions">
<col name="responses"/>
<col name="scores"/>
<col name="feedback"/>
<col name="answers"/>
<row name="immediately" lable="reviewimmediately"/>
<row name="open" lable="reviewopen"/>
<row name="closed" lable="reviewclosed"/>
</optiongrid>



<groupmode/>
<visible/>
')
$questionsperpage =& $mf->get('questionsperpage');
for ($i = 1; $i <= 50; $i += 1) {
$questionsperpage->add_option($i);
}
</pre>

This does not take into account the settings on http://''example.com''/moodle/admin/module.php?module=quiz, which lets the admin move certain quiz options to be hidden behind an "advanced" option. To implement this you would need to add a show/hide advanced control (I would do this as a <yesno name="showadvanced"/>, and an empty advanced group, then use some PHP code like

<pre>
$fix = 0;
$advgroup = $mf->get_field('advanced');

if ($CFG->quiz_fix_timelimit) {
$item = &$mf->remove('timelimit');
$advgroup->add($item)
$fix = 1;
}
// ... and so on, for all the other options. Or you could try to be clever
// and do this as a loop over an array of field names ... then
if (!$fix) {
$form->remove('showadvanced');
$form->remove('advanced');
}
</pre>

===Add database===

[[Image:Formproposal_Add_database_form.png]]

I won't type out full code for this example most of it is simple, and it should be clear how to do it given the above examples, just comment on a couple of things:

'''Entries required before viewing''' I assume this is only indented because the label is so long that having it all lined up would break the table layout. I think our code using CSS for layout just word-wraps long labels and keeps everything aligned, which I think is better.

'''Allow posts to be rated?''' I would put the disabled controls in a group that only appears if the checkbox is checked, so that those controls show and hide, rather than enabling or disabling. However, if we want to keep this the same as it is now, you could implemnt the conditionalenable group type.

===Manage groups for a course===

This sort of form is currently beyond what the form library was designed to produce. I would leave this as hand-coded HTML. In time, the form library may gain some AJAX field types for selecting students, and such like, that could usefully be within a redesigned version of this form. Since the form field types just output HTML and Javascript, it should be possible to use them within hand-crafted forms.

[[Image:Formproposal_Groups_form.png]]

==Questions==

Do we need a syntax like lable='langfile:langstring' for using lang strings from other lang files where necessary? '''yes'''

Where does this live. I think the main library file that people have to include should be lib/formlib.php, and that is all anyone needs to include. However, to we break each field type into its own PHP file, perhaps in a lib/formlib directory, to make it easier to add new field types in future? '''Probably all in one file'''

Some form fields will need bits of CSS and JavaScript to work. Do we add the CSS to the standard theme, and combine all the javascript into a single library somewhere, or do we break it up into the individual field types, and recombine it dynamically at runtime? I think I favour breaking up the PHP code, but keeping all the JS and CSS in one place. '''Should use YUI were possible. We will still need some custom JavaScript and CSS though. Where?'''

Do we use this for vaidation as well? '''Yes.''' Currently Moodle PHP files that do forms tend to look like:

<pre>
$var1 = require/optional_param(...);
// etc. for all the other form variables.

if (data_submitted && confirm_sesskey()) {
// Try to process submitted data.
if (/*processing ok*/)
// Redirect away
} else {
// Set initial form values.
}

// Lots of code to output the form HTML. Of maybe include(somthing.html);
</pre>

The proposal is to change this to something like

<pre>
$mf = new moodle_form();
// Setup $mf with the form structure

$form = new stdClass;
if ($mf->validate_submitted_data($form)) { // Pass by reference to get data back.
// Try to process submitted data in $form
if (/*processing ok*/)
// Redirect away
} else {
// Set initial values in $form
}

$mf->display($form)
</pre>

[[Category:Developer]]
[[Category:Future]]

Roadmap

2007-02-01T22:26:37Z

Pramette: /* Version 1.8 - Expected January 2007 */

This roadmap collects the best information about upcoming features in Moodle. It is not 100% certain - features may change according to available funding and developers.

== Version 1.8 - Expected February 2007 ==

* [[Accessibility]] - Moodle.com
:: Compliance with all major accessibility standards
* [[Moodle forms library]] - Moodle.com
:: All forms can now use a single API for defining forms consistently and collecting data safely.
* [[Multi Authentication]] - Iñaki Arenaza / Jonathan Harker (Catalyst) / Martin Langhoff (Catalyst)
* [[Development:Customisable user profiles|Customisable User Profiles]] - Pukunui Technology
::Allow fields to be added to the user profile.
* [[Moodle Network]] - Catalyst and Moodle.com
:: Setup peer Moodle installations allowing users to roam across, using comprehensive SSO and transparent remote enrolments. Administrators at the originating Moodle install can see logs of remote activity. You can also run your Moodle in "Hub" mode where any Moodle install can connect and users roam across.
::[[Web Services API]] for Moodle communications. The Moodle Network code includes an XML-RPC call dispatcher that can expose the whole Moodle API to trusted hosts.
* Groups refactor - Juliette White / Nick Freear (OU)
::Groups code will be reorganised to make it more flexible for the future (see 1.9)
* Blog commenting
:: You'll be able to make comments on blogs! In time, all comments in Moodle will be merged into the same commenting system.
* [[Authorize.net Payment Gateway]] enrolment plugin
:: Payment managers can obtain an authorization code over phone from customer's bank if the credit card of the user cannot be captured on the internet directly.
* SCORM 2004?
* New Wiki?

== Version 1.9 - Expected April 2007 ==

* [[Repository API]] - Open University, Moodle.com and Humboldt
::Abstract all file operations to an API that allows plugins for different external repositories
* [[Learning Design export]] - Moodle.com and Open University of The Netherlands
::We plan to have a very simple export for any Moodle course into IMS LD format, as a proof of concept and to help the community start learning about IMS LD.
* [[Development:Groups_documentation_for_module_developers|New groups]] - Open University
::Site-wide groups, reusable groups, and assigning activities to groups are the major improvements being developed
* [[Development:Grades|Gradebook development]]
::The gradebook system will be revamped for performance, switching from our older "pull" model to a "push" model where all modules will now publish grades as necessary into a central table.
* [[Metadata]] - Moodle.com
::Build on the keywords in 1.6 to provide metadata for all activities and courses, linkable to standard lists of metadata such as State-based learning outcomes and curricula

== Version 2.0 - Expected July 2007 ==

* [[IMS Learning Design]] - Moodle.com
::Support for importing/exporting LD, converting Moodle activities and sequences of activities into a standard format for sharing, and importing standard sequences into Moodle courses
* [[Conditional activities]] - Moodle.com
::Allowing dependencies and forced paths through the content
* [[Community hub]] interfaces - Moodle.com and others
::Makes it easy for users to find and navigate other systems and external Moodle repositories, leveraging the Moodle Network in various ways.
* [[Student Information API]]
::API for integrating external systems for managing student information

''Note: Moodle 2.0 will require PHP 5.1 as a minimum, because of certain improvements not available in PHP 4.''

== Version 2.1 ==

* [[Portfolio API]]
::Interface Moodle activities and repositories to help produce portfolios for internal assessment AND external publication

[[Category:Developer]]
[[Category:Future]]

[[es:Planificación]]
[[fr:Planification]]

Online Learning History

2006-12-28T16:58:44Z

Pramette:

Let's build up a complete history of key milestones in internet-based learning. Each event should be a heading that includes the date.

==1960 - PLATO ==

PLATO (Programmed Logic for Automatic Teaching Operations) system developed at the University of Illinois at Urbana-Champaign. The system remains in operation until the mid-1990s. [http://en.wikipedia.org/wiki/PLATO_System Wikipedia background on PLATO].

==1962 - R. Buckminster Fuller publishes ''Education Automation'' ==

Relevant quote: "Get the most comprehensive generalized computer setup with network connections to process the documentaries that your faculty and graduate-student teams will manufacture objectively from the subjective gleanings of your vast new world- and universe-ranging student probers." (p.85)

==1969 - Founding of the Internet ==

US DoD commissions ARPANET. [http://www.zakon.org/robert/internet/timeline/ Hobbes Timeline]

==1971 - Ivan Illich's Learning Webs ==

Ivan Illich describes a computer-based education network in his book [http://www.preservenet.com/theory/Illich/Deschooling/chap6.html Deschooling Society]

==1979 - USENET begins ==

USENET established using UUCP between Duke and UNC by Tom Truscott, Jim Ellis, and Steve Bellovin. All original groups were under net.* hierarchy. [http://www.zakon.org/robert/internet/timeline/ Hobbes Timeline]

==1982 - Computer Assisted Learning Center (CALC) ==

The Computer Assisted Learning Center (CALC) was founded in 1982 in Rindge, New Hampshire, as a small, offline computer-based, adult learning center. The center was based on the same premise as today: to provide affordable, quality instruction to individual learners through the use of computers. [http://www.calcampus.com/calc.htm Origins of CALCampus]

==1984 - CSILE ==
CSILE, an educational knowledge media system, developed by Scardamalia & Bereiter at Ontario Institute for Studies in Education. ... CSILE based on Zimmerman's (1989) self-regulated learning (CSILE term is intentional learning) and constructivists' view of learning. It emphasizes on building a classroom culture supportive of active knowledge construction that can extend individual intentional learning to the group level. The purpose is to make students think and reflect their thought process which provoke question asking and answering in a public forum. The ultimate goal is to get students involved in knowledge itself rather than improve one's mind, a World 3 view , which shifts from individual mastery learning to improve the quality of public collective knowledge (Scardamalia, et al., 1994). - from [http://www.edb.utexas.edu/csclstudent/Dhsiao/theories.html#csile]

==1987 - M/EU (Mind Extension University) ==
In 1987, Jones launched M/EU, a cable channel carrying varied educational programming... The advent of the Internet helped facilitate communication in these telecourses.[http://www.media-visions.com/ed-distlrn2.html]

==1988 - Aviation Industry CBT (Computer-Based Training) Committee (AICC) ==
The AICC was formed out of a need for hardware standardization of CBT delivery platforms. Important milestones include: 1989 - Common platform guidelines for CBT delivery (AGR-002), 1992 - A DOS-based digital audio guideline (AGR-003) before the advent of window multimedia standards. The guideline enabled end-users to use one audio card for multiple vendors' CBT courseware. Due to the huge amount of CBT legacy courseware, this guideline is still in use., 1993 - A guideline for CMI (LMS) interoperability was created. This guideline (AGR-006) resulted in the CMI systems that are able to share data with LAN-based CBT courseware from multiple vendors. 1996 - A navigation icon guideline (AGR-009) to help standardize the student user controls in CBT. 1998 - The CMI (LMS) specifications were updated to include web-based CBT (or WBT). This new web-based guideline is called AGR-010. 1999 - The CMI (LMS) specifications were updated to include a JavaScript API interface. (This the basis of the SCORM runtime environment). 2005 - The Package Exchange Notification Services (PENS) guideline (AGR-011) allows Authoring/Content Management system to seemless integrate publishing with LMS systems. [http://www.aicc.org/pages/aicc_faq.htm]

==1992 - CAPA (Computer Assisted Personalized Approach) ==
The system was developed at Michigan State University and was first used in a small (92 student) physics class in the Fall of 1992.[http://web.archive.org/web/20000915112215/capa2.nscl.msu.edu/homepage/]

==1994 - Lotus Development Corporation acquires the Human Interest Group ==

The system evolves into the [http://www-128.ibm.com/developerworks/lotus/library/ls-elearning_evolution/ Lotus Learning Management System and Lotus Virtual Classroom], now owned by IBM.

==1994 - Open University Virtual Summer School==
[http://kmi.open.ac.uk/kmi-misc/virtualsummer.html]

In August and September 1994, a Virtual Summer School (VSS) for Open University undergraduate course D309 Cognitive Psychology enabled students to attend an experimental version of summer school 'electronically', i.e. from their own homes using a computer and a modem. VSS students were able to participate in group discussions, run experiments, obtain one-to-one tuition, listen to lectures, ask questions, participate as subjects in experiments, conduct literature searches, browse original journal publications, work in project teams, undertake statistical analyses, prepare and submit nicely formatted individual or joint written work, prepare plenary session presentations, and even socialize and chit-chat, all without ever leaving their homes.

==1994/95 - CALCampus.com ==

CALCampus was the first to develop and implement the concept of a totally online-based school through which administration, real-time classroom instruction, and materials were provided, originating with the QuantumLink campus. This was a significant departure from earlier methods of distance education because no longer was the individual distance learner isolated from the teacher and from classmates. [http://www.calcampus.com/calc.htm Origins of CALCampus]

==1995 - Mallard web-based course management system developed at the University of Illinois ==
[http://www.uic.edu/depts/adn/itl/uionline/mallard.html Mallard overview]. See also CyberProf[http://web.archive.org/web/19971016101057/cyber.ccsr.uiuc.edu/cyberprof/general/homepage/Newpage/toplevel/welcome.html] (also copyrighted in 1995 from University of Illinois)

==1995 - BSCW 1.0==
[http://bscw.fit.fraunhofer.de/Papers/index.html Papers and timeline are here]

==1995 - Nicenet ICA launched to the public ==
http://en.wikipedia.org/wiki/Nicenet

==1995/6 - WOLF / Learnwise ==
WOLF (Wolverhampton Online Learning Framework)[http://asp.wlv.ac.uk/Level4.asp?UserType=11&Level4=841] developed at Wolverhampton University's DELTA institute under the guidance of Stephen Molyneux. [http://en.wikipedia.org/wiki/Stephen_Molyneux] This went on to be released commercially by Granada Learning as Learnwise [http://www.learnwise.net]

==1996 - TELSI Pro developed ==

TELSI (Telematic Environment for Language Simulations) was a VLE developed at the University of Oulu in Finland. Development was headed by Eric Rouselle and was continued into present day ''Discendum Optima''.

==1997 - CourseInfo releases ILN ==
Mid 1997 CourseInfo founded by Dan Cane and Stephen Gilfus. http://www.news.cornell.edu/chronicle/97/10.16.97/Web_company.html

The "Interactive Learning Network" ILN 1.5, was released and installed at several academic institutions including Cornell University, Yale Medical School and University of Pittsburgh. The ILN was the first e-learning system of it's kind to leverage and install on top of a relational database MySqL. http://www.cquest.utoronto.ca/env/aera/aera-lists/aera-c/97-11/0123.html

==1997 - Manhattan Virtual Classroom in use ==

Manhattan was in use at this time at Western New England College, and included [http://manhattan.sourceforge.net/?What_is_it%3F handouts, assignments, forums etc]

==1997 (about) - Pioneer developed by MEDC (University of Paisley) ==

Pioneer was an online learning environment developed initially for colleges in Scotland. Pioneer was web-based and featured:

online course materials (published by the lecturers themselves)
integral email to allow communications between students and tutors
forum tools
chat tools
timeatable

The main driver for Pioneer was Jackie Galbraith.

When MEDC was closed, the Pioneer development team moved to SCET in 1998 taking Pioneer with them when it became SCETPioneer.

SCETPioneer was used by Glasgow Colleges and a number of other colleges in Scotland.

SCET merged with the SCCC and became [http://www.ltscotland.org.uk Learning and Teaching Scotland]

==1997 - Deployment of Nathan Bodington VLE ==

Development of Nathan Bodington VLE at Leeds University begins from the Bionet TLTP project

[http://bodington.org/history.php History of Bodington]

[http://en.wikipedia.org/wiki/History_of_virtual_learning_environments Dates of Bodington development appear here]

==1997 - WebCT 1.0 was released==
[http://www.webct.com/service/viewcontentframe?contentID=5653208 Powerpoint presentation]

==1997 - Blackboard was founded ==
[http://www.blackboard.com/company/history.aspx]

==1998 - Martin Dougiamas begins preliminary work on Moodle ==
[http://lsn.curtin.edu.au/tlf/tlf1999/dougiamas.html This paper contains some early thoughts]

==1998 - Blackboard released its first software product ==
An online learning application, Blackboard's CourseInfo, developed at Cornell University by the CourseInfo team.[http://www.blackboard.com/company/history.aspx]

==1998 - Nicenet ICA2 is launched ==
Nicenet provides Internet Classroom Assistant (ICA2) with web-based conferencing, personal messaging, document sharing, scheduling and link/resource sharing to a variety of learning environments. http://www.nicenet.org/ica/ica_info.cfm

==1998 - CNAMS 1.0 is released ==
The Cisco Networking Academy Management System (CNAMS) is released to faciliate communication and course management of the largest blended learning initiative of its time, the Cisco Networking Academy. It includes tools to maintain rosters, gradebooks, forums, as well as a scalable, robust assessment engine.

== 1999 ==

*Martin trials early prototypes of Moodle. Martin's paper, [http://lsn.curtin.edu.au/tlf/tlf2000/dougiamas.html Improving the effectiveness of tools for Internet based education,] details one case study and includes screenshots
*Desire2Learn founded in Canada

==2000 - Claroline project was initiated ==

The Claroline project was initiated in 2000 at the Catholic University of Louvain (Belgium) by Thomas De Praetere and was financially supported by the Louvain Foundation.

[http://www.claroline.net/ claroline.net]

[http://www.claroline.net/credits.htm dates and credits]

==2000 - Manhattan 1.0 is released ==

In October of 2000, Manhattan Virtual Campus was released in its entirety on the Internet for free under the GNU General Public License. http://manhattan.sourceforge.net

==2001, November - Moodle.com runs Moodle==
[http://moodle.org/mod/forum/discuss.php?d=1 See this announcement]

==2002 Multiple Events ==
*August - Moodle 1.0 is released
*Summer - Seque Project releases first version of its elearning software
*September - Site@School released

==2004, January - Sakai Project is formed from several college and university projects ==

==2006, June - Moodle 1.6 is released ==

==2006, July 26 - Blackboard announces Patent 6,988,138 ==

[http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO1&Sect2=HITOFF&d=PALL&p=1&u=%2Fnetahtml%2FPTO%2Fsrchnum.htm&r=1&f=G&l=50&s1=6,988,138.PN.&OS=PN/6,988,138&RS=PN/6,988,138 This patent], filed on June 30, 2000 (with pending and related applications dating as early as June 1999) and issued on January 17, 2006, contains very extensive claims pertaining to every aspect of online course delivery. The breadth of this patent would seemingly give Blackboard the ability to enforce this intellectual property against other producers of online course delivery systems.

==See Also ==

http://www.google.com/Top/Computers/Software/Online_Training/Delivery_and_Management_Systems/

http://www.google.com/Top/Reference/Education/Instructional_Technology/Course_Website_Software/

http://en.wikipedia.org/wiki/History_of_virtual_learning_environments

http://en.wikipedia.org/wiki/Computer-assisted_language_learning CALI History in this

http://en.wikipedia.org/wiki/Online_learning#See_also

[http://www.eric.ed.gov/ERICWebPortal/Home.portal?_nfpb=true&ERICExtSearch_SearchValue_0=ED412357&ERICExtSearch_SearchType_0=kw&_pageLabel=RecordDetails&objectId=0900000b8012429a&accno=ED412357 Foundations of Distance Education]

[http://kolea.kcc.hawaii.edu/tcc/tcc_conf97/tcon/0001.html 1997 Conference: Trends & Issues in Online Instruction]

http://www.usdla.org/html/journal/SEP01_Issue/article01.html
mentions: Unix courses @ Nova University early 70s and National Technological University (NTU)

[[es:Historia de la Formación Online]]
[[fr:Histoire de la Formation en ligne]]

Meta course

2006-08-18T15:59:29Z

Pramette:

'''Metacourses''' are courses which take their enrolments from other courses i.e. for every course 'enrolled' on the metacourse, all students in the course are also enrolled in the metacourse.

Each time a student enrols on (or unenrols from) a course, s/he is enrolled/unenrolled from any metacourse(s) associated with it (although it doesn't happen immediately - it may take an hour to show up).

Please note that metacourse enrolments do not preserve groups.

==Metacourse setup==
Teachers are able to choose whether a course is a metacourse via the "Is this a metacourse?" (yes/no) menu option in the [[Settings|course settings]]. If a meta course is chosen, the [[Students|students]] page changes from listing/searching for students to listing/searching for courses.

==Metacourse usage==
Metacourses may be used in a variety of ways:

* '''Scenario 1:''' X is a metacourse with Course 1 through 4 as normal courses with standard student enrollments. Students enrolling on these courses are automatically enrolled onto Metacourse X. This would be used, for example, when every student gets to choose one option from Courses 1-4 but Metacourse X is compulsory for all students taking one of those four options.

[[Image:Metacourses1.png|Standard Metacourse Usage]]

* '''Scenario 2:''' Metacourses 1-4 are linked to Y which is a normal course. Students enrolling on Course Y are automatically enrolled on Metacourses 1-4. This would be used, for example, when all five courses are intended to have exactly the same students.

[[Image:Metacourses2.png|Upsidedown Metacourse Usage]]

In both diagrams you can see students being enrolled normally into standard courses and then the entire student list of a course being added to the Metacourse.

==See also==
* Using Moodle [http://moodle.org/mod/forum/discuss.php?d=48901 Metacourses?] forum discussion

[[Category:Administrator]]
[[Category:Teacher]]
[[Category:Enrolment]]

[[es:Metacourses]]
[[fr:Metacourses]]