SCORM and AICC compared

GerryWaz: Anyone know of a good, dispassionate comparison of the two standards? Strengths and weaknesses of each?

In matters of technology, newer is frequently equated with better. However, while SCORM is the newer specification and is more widely supported, there are valid reasons for using courses and management systems based on the AICC specifications.

Below are some points to consider when deciding between AICC and SCORM. (We consider only SCORM 1.2 and SCORM 2004, since earlier versions of SCORM are effectively obsolete.)

Packaging and deployment

Thanks to SCORM's well-defined packaging model, deploying SCORM courses is often as simple as uploading a zip file. Historically, deploying AICC courses involved more steps due to the lack of a similar packaging model for these courses. In late 2006, AICC published a packaging specification for AICC courses. However, this is still not part of the core AICC specification, so neither AICC-conformant courses nor AICC-conformant LMSs are required to support it. (EKP supports AICC course packages.)

Ease of development

SCORM-conformant courses communicate with an LMS by calling methods of a JavaScript object called the API adapter. AICC-conformant courses communicate with an LMS by sending HTTP messages to the LMS, and interpretting the LMS's responses. (This communication method is known as the HTTP AICC CMI Protocol, or HACP.) Where courses are developed without the aid of specialized course authoring tools, it's usually considerably easier to implement SCORM communication than AICC communication. (However, most specialized course authoring tools shield the developer from these differences.)

Technical requirements

A conformant SCORM API adapter must implement complex rules for validating tracking data and reporting errors and, in the case of SCORM 2004, for evaluating and enforcing sequencing rules and processing navigation requests. Because of this complexity, many robust implementations use Java technology to implement the API adapter, meaning that Java must be available on the user's machine. (Both EKP and ADL's reference implementations use Java to implement the API adapter.) On the other hand, since AICC courses use direct HTTP-based communication, LMSs typically don't require Java to track AICC courses. (However, the courseware itself might still require Java.)

Cross-site scripting

Cross-site scripting occurs when content loaded from one web site in a browser attempts to read or manipulate content loaded from another web site in the same browser. In general, cross-site scripting presents a security risk, and browsers rightly restrict it in most cases. However, these restrictions can also interfere with tracking of courses where the courses reside on a different web site from the LMS. The problem is usually more serious for SCORM courses than for AICC courses. As described above, SCORM courses communicate with the LMS using JavaScript calls, and these are almost always blocked when the course and LMS reside on different sites. On the other hand, due to the nature of AICC communication, AICC courses have greater choice about the specific technology used to perform the communication, and different technologies enforce different policies regarding cross-site communicating. For example, an unsigned Java applet may not communicate with a site other than the one from which it was loaded, but a signed Java applet may do so if the user explicitly grants permission. Even without the use of browser plug-ins such as Java or Flash, an AICC course can implement course-to-LMS communication (but not LMS-to-course communication) simply by using standard HTML forms.

Sequencing

The AICC, SCORM 1.2 and SCORM 2004 specifications all provide sequencing mechanisms—that is, mechanisms for specifying rules concerning the order in which independently trackable units of content can be delivered. (In SCORM terminology, these units of content are called shareable content objects, or SCOs. In AICC terminology, they are known as assignable units, or AUs.) However, only the SCORM 2004 specification requires the LMS to support these mechanisms. On the other hand, it's always possible to implement sequencing in a way that is internal to the SCO or AU. So this is only an issue if you aim to reuse SCOs/AUs at a level of granularity below the course level.

Internationalization

The polite term for the AICC specification's support for internationalization is “boneheaded .” In particular, the AICC specification specifically prohibits the use of Unicode character encodings (e.g. UTF-8, UTF-16), instead requiring the use of one of the ISO 8859 family of encodings. Whereas Unicode encodings support virtually all modern languages, the ISO 8859 encodings support only a very limited set of languages, with Asian languages being particularly poorly supported. (Chinese, Japanese and Korean are all unsupported for example.) There's no good reason for this restriction, and in practice many systems "extend" the AICC specifications to support other encodings. (For example, EKP supports a wide range of encodings beyond the ISO 8859 family, including both UTF-8 and UTF-16.) However, a further problem is that the AICC mechanisms provide no clear way to specify which encoding is being used, so trial and error is often necessary in order to ensure non-English text displays as intended.

Tips on integrating Articulate-created content with an LMS

On Articulate's Word of Mouth Blog, Gabe Anderson has posted a useful checklist of things to look for when integrating Presenter- or QuizMaker-created content with an LMS.

How can I publish an Articulate Quizmaker quiz as an AICC course package that I can import into EKP?

Articulate Quizmaker is capable of publishing quizzes as both SCORM and AICC content. EKP can import and deliver both formats. One advantage of publishing as AICC content is that learners do not have to have Java installed in order to take the quizzes. However, there are a few points to bear in mind when publishing Quizmaker quizzes as AICC content. By following the steps below, you can publish a quiz as an AICC course package and import the package into EKP.

1. Click the Publish button in the Quizmaker toolbar.
2. In the Publish window, choose LMS from the left menu.
3. In the LMS field under Output Options, select AICC.
4. Click Reporting and Tracking...
5. Under LMS Course Information in the LMS Metadata window, complete the Description and Creator fields. Note that if you leave these fields blank, Quizmaker will omit these fields from the published AICC files, resulting in files that are invalid according to the AICC specification. Therefore, in order to produce a valid AICC course package, you must complete these fields before publishing the quiz.
6. The default value of the Filename(URL) field is http://www.servername.com/quiz/index_lms.html. While it's possible to replace this with the full URL at which the quiz will be published, it's easier to simply remove the initial portion so that the value becomes just index_lms.html. (Note that the value should not contain any slash characters.) If you then import the quiz into EKP as an AICC course package as described below, EKP can automatically deduce the full URL needed to launch the quiz.
7. Click the OK button to dismiss the LMS Metadata window.
8. In the Publish window, under Output Options, ensure that the check box labeled Zip files is checked.
9. Click Publish.

The resulting zip file can be imported into EKP using the Import Content Package function (Manage > Catalog Manager > Import Content Package)—simply follow the on-screen instructions.

In summary, the important points are as listed below.

• Be sure to complete the Description and Creator fields in the LMS Course Information section of the LMS Metadata window.
• Enter index_lms.html in the Filename(URL) field.
• Under Output Options in the Publish window, ensure that the check box labeled Zip files is checked.
• Import the published zip file into EKP using the Import Content Package function.

Can I launch courses directly from a portal so that learners don't have to log into EKP, but still have EKP track the learners' progress?

In order to link to a course so that the course launches immediately, and is tracked by EKP, you can link to the launchByCourseId transaction, e.g.:

/ekp/servlet/ekp/launchByCourseId?courseId=My_Course

(Note that this requires that the learner already be enrolled in My_Course, so you might want to pre-enroll learners using a Group Enroll or Auto-Enroll.)

If you link directly to the URL above, and the learner does not yet have a session with EKP, she will be prompted to log in as normal. In order to achieve "transparent login", you can use one of the two mechanisms described below.

1. Implement the "external authentication service" mechanism. To implement this, the portal would need to be modified to generate "authentication tokens" (cryptographic hashes) when requested by EKP. Then, EKP's configuration is modified so that, when it needs to authenticate a user, it redirects to the portal to request an authentication token instead of showing the standard login page.
   
   Note that this mechanism has the significant advantage that it is not required that users' passwords be synchronized in the two systems. In fact, when using this mechanism, the passwords stored in EKP's database are never used.
2. Use the standard verify transaction. This is the transaction that is used to validate a user ID and password submitted using the normal login page. It is possible to add a target parameter to specify the page to which the user should be redirected after a successful login (instead of the normal home page). In particular, if you want to start a course after login, you can specify the launchByCourseId transaction (with appropriate courseId parameter value) as the value of the target parameter. E.g.:

   /ekp/servlet/ekp?TX=VERIFY&UID=joestudent&PWD=password&target=%2Fekp%2Fservlet%2Fekp%2FlaunchByCourseId%3FcourseId%3DMy_Course

   Note that the value of the target parameter has been percent-encoded.
   
   The above example includes the parameters in the query string—however, for security reasons you should avoid including the user ID and password in the URL—therefore, the portal should be coded to use the POST method rather than GET to invoke the verify transaction.

Note that, unlike method 1, method 2 requires passwords to be synchronized between the two systems, which could be difficult to achieve if passwords are changed regularly (a good security practice). (This problem can be avoided by configuring both systems to use the same directory server, i.e. Active Directory or LDAP.) In addition, method 2 requires embedding the user's password in an HTML page (or HTTP redirect header), which might be cached. For these reasons, we recommend using method 1 if possible.

Multiple GlobalEnglish accounts on a single EKP site

About three years ago, we added to EKP the ability to integrate with GlobalEnglish, which provides online English language instruction to global companies. An administrator can create a module in EKP that acts as a gateway to the GlobalEnglish portal, and can then control access to GlobalEnglish in using EKP's standard enrollment mechanisms.

Prior to EKP 5, the GlobalEnglish account details were specified as part of the system configuration. Consequently, only a single GlobalEnglish account could be used with each EKP instance.

However, in large global companies, separate departments sometimes have distinct GlobalEnglish accounts. In EKP 5, we've made it possible to specify GlobalEnglish account details as part of the module configuration, making it possible to use multiple accounts with a single EKP installation.

Here's how to create a module for GlobalEnglish access in EKP 5.

• Go to Manage > Catalog Manager > Module Editor.
• Click the Create Learning Object button in the top frame.
• Enter a Learning ID for the module, and ensure Online is selected as the Learning Type, then click Create.
• On the Define Module Properties page, enter a Title and Description for the module.
• Go the the Define Launch Properties page.
• In the Launch Interface drop-down list, choose GlobalEnglish.
• In the Keycode field, enter the account keycode as provided by your GlobalEnglish representative.
• Click the Save button in the top frame.

Batch importer for SCORM courses

EKP has long featured a batch importer for AICC-conformant courseware. Starting with EKP 4.7, the importer also supports SCORM-conformant courseware.

To use the batch importer, you'll need to create a new zip file that contains the individual SCORM content packages. (IMS content packages will work too.) Since these content packages are themselves zip files, you'll have a zip file that contains multiple individual zip files as entries. Then, go to Manage > Catalog Manager > Import Content Package, select the zip file you created, and click the Next > button.

EKP will display a summary of the courses that will be imported, and will walk you through the various import options. Just follow the on-screen instructions. (The process is pretty much identical to the AICC batch import process.) And, if you make a mistake, there's also a batch delete function that you can use to undo your changes.

Improvements to bulk courseware import tool

We just made some improvements to the bulk courseware import tool. This tool makes it easy to import many AICC-conformant courses in a single step. To use it, simply package the course structure files for the courses in a single zip file, then go to Manage > Catalog Manager > Import Content Package and upload the zip file. (Each course should have a set of four files, with the same base file name, and file name extensions .au, .crs, .cst and .des respectively. Some tools and vendors provide extra files, but EKP doesn't need them.)

Perhaps the most useful change is that EKP now shows the full titles and IDs of several of the courses in the package on the import options screen right after you select the package and the character encoding. That lets you see what courses are available in the package before running the import. It's also helpful if you're not sure what character encoding to use, since you can check that the course titles look correct before running the import, and if not you can return to the previous step and choose a different encoding.

EKP also now shows full course titles in addition to IDs on the summary page once the bulk import is complete.

We've also simplified the process in the case where the package contains only a single set of course structure files. In this case, the process is almost identical to importing a SCORM content package, and EKP will provide a detailed error report if it finds any problems with the files.

These changes will be available in versions 4.6.0.83 and 4.5.1.197.

Why does my SCORM course display an "Unable to find an API adapter" message?

When a SCORM course is packaged in a zip file (sometimes called a PIF, which stands for Package Interchange Format), the package needs to contain a manifest file named imsmanifest.xml. This file is used by delivery systems such as EKP to understand the contents of the package.

A SCORM course contains one or more resources (roughly speaking, the "lessons" in the course). In SCORM 1.2, each resource is either a sharable content object (SCO) or an asset. A SCO is specially designed to communicate with a learning management system (LMS)—for example by informing the LMS about the learner's test scores or other progress information—which it does using JavaScript calls. On the other hand, an asset is not specially designed to communicate with an LMS—essentially, it is just regular web content.

The manifest file contains information about each resource, together with an indication of whether each resource is a SCO or an asset. A typical XML element for a resource might look as shown below.

<resource identifier="R1" type="webcontent" adlcp:scormtype="sco" href="sco01.html">

Note the adlcp:scormtype attribute. There are two possible values for this attribute, sco and asset, corresponding with the two resource types described above. If the type is specified as sco, EKP will provide a JavaScript object called the API adapter, which the SCO can use to communicate with EKP. If the type is specified as asset, EKP assumes that the resource is not designed to communicate with an LMS using JavaScript, and therefore does not provide the API adapter. (Instead, EKP provides a button labeled Mark As Completed, which the learner can use to indicate that they have completed the activity.)

In particular, note that if the adlcp:scormtype attribute is omitted, EKP assumes that the resource is an asset, and therefore does not provide the API adapter.

If you see an error message that reads Unable to find an API adapter or similar when launching a course that has been imported from a content package, it might be that either the resource has incorrectly been tagged as an asset, or the adlcp:scormtype attribute is missing entirely. In this case, the problem can be fixed by manually editing the imsmanifest.xml file to include the correct attribute values for each resource.

There's one final XML technicality to be aware of. In order ensure that the attribute name adlcp:scormtype can be understood without ambiguity by an XML processor, it's necessary to ensure that the XML file contains a namespace declaration that corresponds with the namespace prefix adlcp. This declaration takes the form of an XML attribute that is usually placed on the root element of the file. The attribute is as shown below.

xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_rootv1p2"

The initial opening tag of a manifest file that contains this attribute might look as shown below.

<manifest identifier="M1" version="1.1"
    xmlns="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
    xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_rootv1p2">

Why doesn't the Exit button in my course work?

This is an area where the courseware standards (SCORM, AICC) don't really correspond with real-world usage.

According to SCORM, exiting a course is considered a navigation event and so should not be invoked by the course itself—only the run-time environment (typically LMS) is supposed to control navigation. This is related to the SCORM philosophy of "reusable objects"—if an content object (SCO) contains a button that closes the window then it's making strong assumptions about where it will run (i.e. in a separate window rather than as part of a larger course) and hence is less reusable. So if one were to follow SCORM to the letter then the course should not have an Exit button at all.

In reality almost nobody does it that way—having an Exit button is a very common requirement.

EKP typically launches courses inside a frameset—frames are used for navigation, and a "hidden" frame is used for the SCORM API adapter. That's why window.close() won't work—it tries to close the frame rather than the top level window. If you use window.top.close() instead it should work in EKP. (Note: the name of the window object in JavaScript might be misleading, as it can refer to either a frame or a top-level window.) But there's no single method that's guaranteed to be 100% portable across LMSs, even if they are SCORM- and/or AICC-conformant.

How do I enable Java tracing on a client machine?

When investigating issues related to SCORM courseware tracking, NetDimensions support staff might sometimes ask you to enable Java tracing on the client machine. Enabling Java tracing causes information about API calls made by the course to be written to a trace file on the client. The steps below describe how to enable Java logging when using Sun Microsystems' Java Runtime Environment (RTE).

1. Open the Java Control Panel. (On Windows, this can be done by going to Start > Control Panel, and double-clicking the Java icon.)
2. In the Java Control Panel window, click on the Advanced tab.
3. On the Advanced tab, expand the Debugging item by clicking on the plus sign icon.
4. Ensure the checkbox labeled Enable tracing is checked.
5. Click OK.

By default, the trace file is written to the <user>\Sun\Java\Deployment\log directory on Windows. Sun Microsystems' web site has more information on Java tracing and logging.

Note that the information written to the log file is generally the same as is available in the Java console. However, unlike the console, the information in the log file is still available after a browser restart or browser crash.

How do I enable HACP tracing?

When investigating issues related to courseware tracking, NetDimensions support staff might sometimes ask you to enable HACP tracing. Enabling HACP tracing causes detailed course tracking information to be written to the server log file. (HACP is the HTTP AICC CMI Protocol, which is what most AICC-conformant courses use to communicate with EKP.)

• To enable HACP tracing temporarily (until next system restart), go to Manage > System Administration Manager > System Support Functions > Debug/Tracing Options. Ensure ON is selected in the drop-down list labeled HACP Tracing, then click Save.
• To enable HACP tracing permanently, ensure the value of the system.aicctrace property is set to true in the ekp.properties configuration file (which is located in the WEB-INF/conf/ directory). That is, the ekp.properties file should contain the line below.

  system.aicctrace=true

  This change to the ekp.properties file will take effect the next time EKP is reloaded.

It will often be desirable to make both of the changes described above.

What is PENS, and when should I use it?

Starting from version 4.5, EKP supports the Package Exchange Notification Services (PENS). PENS enables one-click publishing of courses from a PENS-conformant authoring tool or LCMS to EKP. Note that PENS is not a format for learning content like SCORM or AICC CMI001. That is, by itself it does not define any formats or protocols for course catalog metadata, course structure, course/LMS communication, or sequencing. PENS simply defines a way for a publishing tool to notify a delivery system (LMS) that new content is available for collection. The relevant content is still transferred using an establish format such as SCORM or AICC packages (most commonly the former).

So PENS is not an alternative to, say, SCORM content packages. Rather, it simply eliminates the step of manually exporting a content package from the publishing system and then importing it into EKP. Note that if your workflow requires you to make use of the packages (e.g. you need to manually modify the packages, or wish to archive them outside of EKP) then it's probably not appropriate to use PENS.

How can I use PENS to enable one-click publishing from an authoring tool or LCMS to EKP?

Starting from version 4.5, EKP supports the Package Exchange Notification Services (PENS). PENS enables one-click publishing of courses from a PENS-conformant authoring tool or LCMS to EKP.

To configure the authoring tool or LCMS to publish courses to EKP using PENS, you will need three pieces of information: a URL, a user name, and a password.

The URL is simply the base URL for the site, followed by pens. A typical URL is shown below; if you have changed the default protocol or path for your site, you'll need to modify this URL as appropriate.

http://ekp.example.com/ekp/pens

(N.B. If you encounter problems, check that you can access the PENS URL directly in a browser. You should get a response similar to the one below. If you see a 404 Not Found message or similar, there might be a configuration problem with your web server; see I get a 404 Not Found page when accessing EKP's PENS URL, what should I do? for an explanation of how to resolve it.)

error=0
error-text=collect command received and understood
version=1.0.0
pens-data=

The user name and password should correspond to an EKP user in a role that allows them to import courses.

Can I create a custom Table of Contents for a multi-SCO SCORM course?

A SCORM-conformant course contains one or more Sharable Content Objects (SCOs). A SCO is defined as the smallest unit of content that can be independently tracked by a SCORM-conformant run-time environment (i.e. an LMS). Although it's quite common for courses to be built using only a single SCO, this post concerns courses that are built using more than one SCO.

Where a course contains multiple SCOs, it needs to be set up in EKP in such a way that EKP is aware of the individual SCOs. Normally this happens automatically if the course is imported from a SCORM content package, as the imsmanifest.xml file in the package tells EKP what it needs to know about the individual SCOs. (If necessary, the same thing can also be accomplished manually using the Courseware Manager, by creating a separate lesson for each SCO and setting the Run-Time Environment for each lesson to "JavaScript API".) When the course is set up in this way, EKP provides navigation controls that learners can use to navigate between the SCOs. (If the course is built using only one SCO, these navigation controls are redundant and do not appear.) In this way, EKP can keep track of which SCO the learner is currently attempting, and can ensure that any progress information communicated by a SCO is associated with the appropriate SCO in EKP's records. EKP can also "roll-up" progress information from each lesson to provide overall progress information for the course.

However, this only works if EKP's own navigation controls are used to launch the SCOs; it won't work if you attempt to create a custom Table of Contents page and link to the individual SCOs from there. This is because EKP is unable to keep track of which SCO the learner is currently attempting—and, in fact, EKP is unaware that the course contains multiple SCOs. Any progress information communicated by an individual SCO will therefore be interpreted as course-level progress information; so, for example, when an individual SCO reports that it is completed this will be interpreted as completion of the course as a whole.

The solution is to avoid using a custom Tables of Contents for multi-SCO courses. Instead, import the course using the original content package, and ensure that the learner navigates between the SCOs using the navigation controls provided by EKP. (On the Navigation Setup page in the Catalog Editor, you can configure for each individual multi-SCO course whether EKP displays the top navigation frame only, the left navigation frame only, or both frames. You can also customize the look-and-feel of EKP's navigation controls by creating a courseware template and uploading it under Manage > Courseware Manager > Courseware Template Editor.)

I get a 404 Not Found page when accessing EKP's PENS URL, what should I do?

Starting from version 4.5, EKP supports the Package Exchange Notification Services (PENS). The URL used for notifications is typically /ekp/pens.

If you see a 404 Not Found error when attempting to access this URL, it's likely that your web server (e.g. Apache HTTPD) is not configured to forward requests for this URL to your application server (e.g. Apache Tomcat).

If your web server is Apache, you can fix this by editing the httpd.conf configuration file, which is in the conf/ directory under the Apache installation directory. If you open this file in a text editor, you will find a series of "directives" such as the following:

JkMount /ekp/tx/* ajp13
JkMount /ekp/servlet/* ajp13
JkMount /ekp/*.jsp ajp13
JkMount /ekp/servlet/ekp/* ajp13
JkMount /ekp/*.tx ajp13
JkMount /ekp/xml/* ajp13

(Note: in some installations, the above directives might be in a file named mod_jk.conf under the directory conf/jk/, instead of in httpd.conf itself.)

To enable PENS support, you should add one more directive as follows:

JkMount /ekp/pens ajp13

You'll need to restart Apache for that change to take effect. Note also that if the prefix for your site is something other than /ekp, you'll need to modify the directive above as appropriate.