Make your Captivate movies more accessible

Adobe has a short but useful article detailing how to make your Adobe Captivate movies more accessible.

These are pretty simple (borderline “no-brainer”) steps a Captivate author can easily implement:

  • Add a description to an Adobe Captivate movie
  • Add a description to an individual slide
  • Limit quiz questions to multiple choice, true and false, and Likert scale (short answer and matching question types are not accessible).
  • If you use audio in your project, use Captivate’s closed captioning feature.
  • Ensure the “508 compliance” option is checked when publishing the project (this option is enabled by default). The “508 compliance” feature automatically makes Captivate ‘click areas’ keyboard-accessible.

I haven’t tested how well the accessibility features work, but it’s nice to know that Adobe has made a genuine effort to make Captivate (and Flash) SWFs more accessible. Matter-of-fact, Adobe has quite an impressive “accessibility” section on its website, providing guidance for making almost any Adobe-published media file (SWF, PDF, HTML, etc.) more accessible.

Read the Adobe Captivate article here.


Example files for SCORM AS3 class updated

A number of people emailed me reporting problems using the demonstration files for the ActionScript 3 SCORM class. Turns out the imsmanifest.xml file was causing the problems; apparently, one of the supporting XML files was corrupt. After creating a new imsmanifest.xml file and bringing in fresh copies of all the supporting XML files (the ADL/IMS stuff), the example launches as expected.

The new demo files pass the ADL SCORM 2004 Test Suite (both the SCO RTE conformance test and the Manifest Utility Test). They also work fine in Moodle (v1.8), which seems to be the LMS of choice for most of the people who contacted me.

Sorry for any frustration this may have caused you. The good news is there were no bugs in the ActionScript and JavaScript code! 🙂

Visit the downloads page to get the latest files.

SCORM wrapper examples tested successfully in SumTotal TotalLMS 7.6

The pipwerks SCORM wrapper examples have been successfully tested in SumTotal TotalLMS 7.6.

FYI, the examples’ imsmanifest.xml files required some modifications (the old manifests worked fine in the ADL test suites, but coughed a little when used in SumTotal TotalLMS 7.6). The JavaScript, ActionScript and HTML in the examples remain unchanged. If you’ve previously downloaded the examples, I suggest you download the updated versions to get the newer manifests. Of course, if you’re a pro at manifests (Aaron?), you could always make better ones… making the imsmanifest is my least favorite part of working with SCORM.

As always, if you test these in your LMS, please let me know — even if it doesn’t work! Thanks 🙂

Really simple SCORM AS3 wrapper example

Here’s a simple example of how the SCORM AS3 class can be utilized. (This example uses SCORM 2004 calls.)

import pipwerks.SCORM;
import flash.external.ExternalInterface;

//Declare variables
var success:Boolean = false,

//Initialize a new SCORM object!
var scorm:SCORM = new SCORM();

//Initialize SCORM connection
success = scorm.connect();

//If connection attempt was successful
    //Get completion status
    completion_status = scorm.get("cmi.completion_status");
    //If course has already been completed
    if(completion_status == "passed" || completion_status == "completed"){
        //Disconnect from the LMS.
    } else {
        //Set course status to incomplete
        success = scorm.set("cmi.completion_status", "incomplete");

            success = scorm.disconnect();
        } else {

} else {

function serverUnresponsive():void {
    var msg:String = "Sorry, can't connect to server. Please try again later.";
    trace(msg);"alert", msg);

Here’s a slightly more fleshed out example. (This example uses SCORM 2004 calls.)

import pipwerks.SCORM;
import flash.external.ExternalInterface;

//Declare variables
var success:Boolean = false,

//Initialize a new SCORM object!
var scorm:SCORM = new SCORM();

//Initialize SCORM connection
success = scorm.connect();

//If connection attempt was successful
    //Get completion status
    completion_status = scorm.get("cmi.completion_status");
    //If course has already been completed
    if(completion_status == "passed" || completion_status == "completed"){
        //Disconnect from the LMS.
    } else {
        //Set course status to incomplete
        success = scorm.set("cmi.completion_status", "incomplete");

        // --- Set other SCORM settings as needed -----
        if(success){ success = scorm.set("cmi.score.min", "0"); }
        if(success){ success = scorm.set("cmi.score.max", "100"); }
        } else {
        //You can get data from LMS using the following syntax
        learner_name = scorm.get("cmi.learner_name");
        bookmark = scorm.get("cmi.location");
        if(bookmark != null && bookmark != ""){
            //Use bookmark
        } else {
            //Start from beginning
            success = scorm.set("cmi.location", "page1");
            } else {
        //Do other course stuff as needed...
        //End course
        var score:int = 80;

} else {

function finishCourse(score:int):void {
    //Score must be converted to a string before it can be passed to LMS
    var success:Boolean = scorm.set("cmi.score.raw", String(score) );
    if(success){ success = scorm.set("cmi.completion_status", "completed"); }
        success = scorm.disconnect();
    } else {

function serverUnresponsive():void {
    var msg:String = "Sorry, can't connect to server. Please try again later.";
    trace(msg);"alert", msg);

Flash demos for SCORM ActionScript classes now available

Finally got around to making some Flash files that demonstrate the pipwerks SCORM ActionScript classes. I’ve created examples for both AS2 and AS3. You can get them here.

Both of these examples have been successfully tested using the latest ADL test suites for SCORM 1.2 and 2004.

A word about the code in the Flash examples

I just thought I should point out that there are many ways to build a course in Flash, and the method I used for these examples is just one. I kept it very simple, and wanted to stick to the basics; these examples are designed to show you how easy it is to integrate the SCORM class into a course, and not much else!

There’s a bunch of extra error-checking and debugging code in there to help illustrate the course-to-LMS communication facilitated by the SCORM JS wrapper and AS classes.

Note: Although the ActionScript 2 example uses SCORM 1.2 and the ActionScript 3 example uses SCORM 2004, when creating your own courses with these wrappers, you can mix and match any way you like. You can use AS2 with SCORM 2004 or AS3 with SCORM 1.2… it’s completely up to you.

Why don’t more e-learning developers use standards?

Question: Why don’t more e-learning developers use standards?

I don’t know for sure, but I have a number of guesses. Here’s a quick list off the top of my head:

  • Lack of knowledge about standards
  • Confusing or obtuse documentation
  • Competing standards
  • Misconceptions about cost effectiveness
  • Difficulty / Lack of support in development tools

This is a sort of stream-of-consciousness post, so I’m sure I’m missing a few things. Feel free to add your two cents.

Lack of knowledge about standards

It’s my opinion that a large number of e-learning developers are non-technical, or are mid-level techies who came into the field from other areas. Not having a background in web development, many of these developers probably don’t know that using tables for layout purposes is a faux-pas, or realize the power of well-written CSS. Many of these developers probably rely on their e-learning development tools to handle that stuff for them.

And for those who know all about web standards, e-learning standards are a whole ‘nother beast. Being a master with CSS doesn’t mean you’ll easily grasp the depths of SCORM’s murky sequencing features. Which leads us to…

Confusing or obtuse documentation

I like SCORM. I also hate SCORM. Such is life.

There are a number of proposed standards for e-learning courseware, with SCORM and AICC probably leading the way. However, AICC is considered out of date, and SCORM is considered difficult to use. As with many proposed standards, I believe SCORM’s steep learning curve lies largely in the really hard-to-read documentation and unclear examples.

My apologies to those who wrote the documentation — I do think it’s very thorough — but for someone who isn’t familiar with SCORM, trying to get a handle on it by reading those documents is a very frustrating experience. I think Claude Ostyn’s Cooking Up a SCORM and Eye of the SCORM documents were the most reader-friendly SCORM documents available, but with his unfortunate and untimely passing, they probably won’t be updated.

Competing standards

SCORM isn’t the only standard out there. As some of you may recall from my previous post, the IMS Global Learning Consortium (among others) has created a number of proposed standards for the world to use, including the IMS manifest (which accompanies every SCORM course), the Question and Test Interoperability specification, and most recently, the ultra-secretive Common Cartridge proposal.

Having tried my hand at using these IMS standards, lemme tell ya, they are not easy or fun to use. Big disincentive from the start. (The IMS takes inconvenience one step further by making it difficult to even figure out exactly what their standards are.)

The IMS is working on the Common Cartridge Alliance. According to some, it’s a SCORM killer that will revolutionize e-learning courseware.

However, SCORM is much more established, and has been adopted by every major LMS vendor. Assuming the Common Cartridge is as good as promised (and the specification ever becomes publicly available), it will force developers to choose sides.

Backing off of e-learning standards for a minute, what about other competing standards? There are no shortage of standards to choose from: HTML 4 versus XHTML 1.0 (and soon HTML 5 versus XHTML 2.0); Internet Explorer (and its proprietary ActiveX controls) versus Firefox/Safari/Opera/et al, Adobe Flash versus the new kid on the block Microsoft Silverlight, etc.

Making sound choices involves homework on the issues. Oftentimes, I think people make their choice based on ease of use (“does my WYSIWYG editor support it?”) or cost. This is a fair point; after all, we can only do what our budgets allow, right? Well…

Misconceptions about cost effectiveness

One of the biggest arguments against standards and best practices is the amount of time it takes to get up and running with standards.

When it comes to web standards such as valid XHTML markup and CSS-based layouts (separating content from presentation), I think a small amount of time getting acquainted with the techniques pays big dividends in the long run. When using standards and best practices, you’ll spend less time troubleshooting browser compatibility, less time updating the look and feel (external CSS makes it so much easier!), and less effort making the course work in different mediums (standard web browser versus mobile versus text reader, etc.).

Using standards also ensures your courseware will have a longer shelf life.

It’s too expensive to NOT use standards and best practices.

Difficulty / Lack of support in development tools

A hot topic of late is the quality and capabilities of e-learning development tools. Personally, I don’t use them very much except for special needs, such as making animated screen captures in Captivate and/or Camtasia. I normally stick to standard web development tools such as Dreamweaver and Flash Professional.

However, I totally understand the needs of many others out there who don’t have the time and/or expertise to make courseware from scratch; there’s a reason the e-learning development tool field has really bloomed the last few years, and it won’t slow down anytime soon.

But as I’ve mentioned before, these tools most often do not support web standards or best practices. What’s worse, they often completely ignore standards while making the purchaser/user of the software think they’re getting top-notch, state-of-the-art stuff. It’s false advertising, but it’s also effective marketing. Very effective.

I wish the e-learning tools market would shape up and self-regulate! (Riiiight…) Hey tool developers: Use standards because they matter. Use best practices because they’re best practices for a reason. If you incorporate standards and best practices in this young niche market, you could very well find yourself top-shelf in a matter of months. If you were already top-shelf, you could become uber-elite. Think about it.

So what can we do?

I know I keep espousing standards without really giving enough concrete know-how and direction. Honestly, I’ll be the first to admit I don’t have the answers — but maybe together we can do something about it. I’m proposing we create a community-defined set of simplified e-learning development standards that can be viewed more as ‘rules of thumb’ than law.

For starters, a standard like SCORM is very intimidating because of its intricacies and density. Claude Ostyn’s writings were enlightening if only because the first thing he did was show an extremely simple example of a single-page course. His point was that just because SCORM can be used in-depth doesn’t mean it has to be. We can just use it for what we need and ignore the rest. A great example is SCORM’s page sequencing and navigation system; it’s really tricky to figure out, and requires a really complicated imsmanifest.xml file. If your course only has a few pages, or if you already have a decent navigation system worked out, don’t use SCORM’s navigation features. You can still create a SCORM-conformant course (SCO) that will work with any SCORM-conformant LMS!

Got ideas?

So how about it? I’m going to start writing down simple, easy-to-digest rules of thumb that I hope someone will find useful. I intend to provide examples and/or links with every concept. Will you help me? Maybe together we can get this thing turned around.

New: SCORM API wrapper for ActionScript 3.0

I just converted my AS2 SCORM class to AS3.

Read documentation and download file(s) here. Note this class requires the pipwerks SCORM API wrapper for JavaScript.

Not being much of an AS3 guy (so far!), it was easier than I expected; I guess since I had already used strong typing in AS2 it met most of the AS3 requirements for strong typing. The only other changes between the AS2 and AS3 classes are pretty simple:

  • Added the AS3-required ‘package’ wrapper. I used the package name “pipwerks”; if you use this class, you’ll need to either place the class in a subfolder named pipwerks, or rename the package. It’s not a requirement, but I’d appreciate it if you left the pipwerks in there. 🙂
  • Converted all “Number” variables to “int”
  • Changed all “Void” function return types to “void”

I think that’s it…

As always, please give me feedback! Let me know if it does or doesn’t work for you, if you find any bugs, or if you have any suggestions for improvements.

New: SCORM API wrapper for ActionScript 2.0

I just finished an ActionScript 2.0 class file meant to be a companion to my JavaScript SCORM API wrapper.

Update: AS3 version now available, too.

Simplified syntax

The idea was simple: give me (and others) a way to make SCORM calls using ExternalInterface without having to constantly type ExternalInterface!

So now instead of typing the tedious

var student_name:String = String("", "cmi.core.student_name"));

we can just type

var student_name:String = scorm.get("cmi.core.student_name");

To initialize a course, you can just do the following:

var scorm:SCORM = new SCORM();

Usable return values and automatic ExternalInterface error-checking

The class includes type checking, type conversion, and error-checking to help avoid running into the same annoying issues over and over again. Let the class worry about that stuff, so we can just request our data! 🙂

You can use the boolean return types to ensure your course works as expected. For instance, you could do something like:

var scorm:SCORM = new SCORM();

var isConnected:Boolean = scorm.connect();


   var lesson_status:String = scorm.get("cmi.core.lesson_status");

   if(lesson_status == "completed" || lesson_status == "passed"){


   } else {

      var success:Boolean = scorm.set("cmi.core.lesson_status", "completed");





The class has been successfully tested in the ADL SCORM 1.2 test suite (1.2.7), but is designed to be version-neutral, working exactly the same with both SCORM 1.2 and 2004 — just make sure you have the required JavaScript wrapper.

The JavaScript wrapper determines your SCORM mode (1.2 or 2004) when it finds the API; you never have to state which version of SCORM you’re using in your JavaScript OR your ActionScript! If you use this class for SCORM 1.2 and decide to transition to SCORM 2004, you won’t have to change the class file or the JavaScript wrapper.

If you’re keeping the same course functionality and not adding new features, you’ll just need to change some of the variable names in your own course ActionScript, such as going from “cmi.core.lesson_location” to “cmi.location”.

If you want to add SCORM 2004 features, the wrapper is already set up for it, just use the appropriate syntax, such as var progress:String = scorm.get("cmi.progress_measure");.

(In case you’re wondering how the scripts know which version of SCORM is being used, the SCORM version is declared by the imsmanifest file and the course settings when importing the course into the LMS.)

Get the class file

You can get the class file and read the (meager) documentation at

PLEASE give me feedback!

Please try it out and let me know what you think! I’m still testing it out and would appreciate any feedback or suggestions you might have. Thanks in advance!

Building e-learning courses: Should we use e-learning authoring tools?

This post was triggered by BJ Schone’s question “How do you build e-learning courses?

So, here’s my question: How do you build your e-learning courses? Do you build them from scratch (ex. HTML, JavaScript, etc.)? Do you use an authoring tool for the whole course structure?

This is an interesting question. Personally, I use home-grown solutions, not any particular e-learning authoring tool, though I often use e-learning authoring tools such as Adobe Captivate to create some of my animated content.

However, I think before you can really dispense advice which particular development approach is best, there are a number of factors to consider.

Questions abound

Who’s using the tools?

Development tools are generally used for two things: creating new courses and updating existing courses.

Here are two common scenarios for teams creating new courses:

  1. The team is large, with specialists. I know of some e-learning companies who have specialists for each type of project task, with strict orders to maintain the development boundaries: the instructional designer only works on curriculum development, the writer only writes, the web developer only works on the technological elements, the graphic designer only works on graphic elements, the subject-matter expert only provides insight about the topic and is not involved in any technological development tasks, etc. Apparently this makes it easier to subcontract the work and replace or augment team members where needed.
  2. The team is small, with generalists. In most cases, each person in an e-learning development team wears multiple hats: the instructional designer also does some web and/or graphic design, the subject-matter expert writes large chunks of the curriculum, etc. There often isn’t an experienced web developer on the team, so the team may be forced to learn an off-the-shelf program such as Captivate or Lectora just to get the course out the door. Sometimes, if the team can afford it or is in a time crunch, they may hire a subcontractor to do the technical work.

I think situation #1 lends itself to standard web development tools, whereas situation #2 lends itself to e-learning authoring tools. More on that in a minute.

When you get to updating courses, the question becomes: Who is responsible for maintaining the course? If the course is internal, do your coworkers know how to use the software, too? If the course was for a client, are they expected to purchase the development tools you used, and have enough technical expertise to use them?

Is portability a concern?

The portability of the content is an often-overlooked issue. When I speak of portability, I mean portability in three senses:

  1. Portability as a course from one LMS to another
  2. Portability of the content fragments within a course from one course to another
  3. Portability of the entire course to other file formats or mediums, such as XML, PDF, a database, etc.

What about accessibility?

We should never forget that there are a significant number of people taking our courses who may have special needs, including people who may be deaf, blind, color-blind, have low-vision, or other physical impairments (such as limited ability to use a mouse or keyboard).

Where are you going with this?

Buckle your seatbelts, you may not like this statement: Most e-learning tools do not promote the creation of effective courses, do not promote web standards, and do not promote accessibility; they merely make cookie-cutter course development easier for technically inexperienced course developers.

There, I’ve said it. Please don’t hate me.

Let me take a few moments to explain my thoughts on the subject.

Effective courses

Let me be clear: I am NOT saying that e-learning tools cannot create effective courses. However, I do believe that the templatized nature of most e-learning development tools leads many course developers to favor convenience over effective communication and education.

More time is spent on shoehorning course content into templates, and less time is spent on the instructional design aspects of course-building, where you stop and ask “how can I really engage the audience during the course?” (And by ‘engage’ I don’t mean just adding a simple quiz question.) Personally I don’t find the pre-built interactions in many e-learning tools to be very good. And the few that are good tend to be so overused that they get stale fast.

Since many of the developers using these authoring tools are not experienced web developers, they rarely venture ‘outside the box’ with the tool, and tend to stick to the course options presented by the software. Thus, the course developer’s options are often limited to the tool manufacturer’s instructional design preferences and notions of what constitutes a ‘proper’ course. This may lead to a boring, unimaginative course, or even worse, a course that doesn’t meet the needs of the learner.

My gist is that the tool, with its limitations and hard-coded inclinations, often winds up driving the end product more than the instructional designer. This is not unlike PowerPoint’s relationship with presenters, and how PowerPoint templates have reshaped modern notions of what a good presentation should be.

As I see it, PowerPoint presentations became the standard for two key reasons: they make presentations seem more ‘official’ or ‘professional,’ and entry-level users found the software’s templates to be very easy to use.

PowerPoint is not the answer

“Need to create an online course but don’t know how? Our tool allows you to convert your existing PowerPoint presentations into effective, engaging courses in MINUTES!”

This sounds like a dream come true for non-technical people who need to create an online course fast. But let me ask you a question: how many GOOD PowerPoint presentations have you seen that were created by non-designers? C’mon, be honest… we all know that 90% of PowerPoint’s built-in templates are ugly and hard to read.

More importantly, truly effective PowerPoint presentations are secondary (and complimentary) to a good, dynamic classroom trainer. These presentations are often simple outlines, minimalist in nature, designed to focus the attention on the presenter, not the PowerPoint file.

Simply stated, a PowerPoint presentation is designed to display a linear presentation of bullet points. How does a linear presentation of text (perhaps with a few animations thrown in) have any bearing on effective web-based training? Short answer: it doesn’t.

To expect a trainer’s PowerPoint presentation to be an effective online course without the trainer is preposterous. The trainer’s experience, charisma, presentation skills, and ability to fine-tune the course content to the needs of the individuals in the classroom is paramount.

(An ugly little secret in our industry is that quite a few course developers — and clients — don’t care about the effectiveness of the training nearly as much as they care about being able to say the training has been created and is available to the client. But rest assured: If you’re reading this, you probably aren’t one of them.)

e-learning development tools

I’m not implying that all e-learning tools follow the “let’s import PowerPoint!” model of course building, but you can’t deny how rampant PowerPoint-to-e-learning conversion tools have become in our industry. My belief is that our industry (and others) has a fixation on PowerPoint simply because of its ease of use.

The most popular e-learning tools I’m aware of today are Adobe Captivate, Articulate Presenter, Rapid Intake’s FlashForm, and Lectora. What do these all have in common? They’re geared towards users with little or no development expertise. Yes, they’re geared towards the PowerPoint crowd.

Each of the tools has its strengths, and I’m not telling people not to use them. However, I’d like to point out that each of the tools either creates files in proprietary formats (which requires purchasing their product just to make edits), or outputs courseware that doesn’t adhere to web standards and best practices.

What’s the alternative?

Using standardized web development techniques, including writing valid page markup, maintaining the separation of content from presentation via valid cascading stylesheets, and using unobtrusive JavaScript, will free your course from the shackles of a proprietary e-learning development tool format.

The most persuasive argument for using specialized e-learning development tools has been maintenance — the desire for easy updates and not relying on technical experts to handle the editing.

But I disagree; not being tied to a particular tool or proprietary format means that practically anyone with general web development experience will be able to make edits to your course or even create new courses using your system. Millions of people around the world work with HTML, and hundreds of thousands work with JavaScript. I’m willing to bet that the number of people familiar with proprietary e-learning development tools is much smaller, probably numbering in the thousands. It’s a niche.

Maintaining courses built with web standards means you can hire just about any college student or web designer to come in and make changes. It means YOU can make changes if you learn a little about HTML, or use a standards-supporting WYSIWYG editor such as Adobe Dreamweaver. The key is for your course system to adhere to web standards.

ELearning software that outputs to HTML (such as Lectora and ToolBook) do not output HTML documents that adhere to web standards. Same for many homegrown proprietary formats that have caused grumbles in offices like yours and mine. Not only are these courses harder to update, but they’re more likely to have browser compatibility issues and are less likely to be ‘future proof.’ Adobe Captivate is a good example: The latest Captivate SWFs aren’t even compatible with Flash SWFs created in Flash CS3 (publishing to ActionScript 3).

Using standard web technology means you will have the greatest flexibility possible, including the ability to embed rich media (Flash, Quicktime, etc.) whenever you like. It also means your courses will work in the largest percentage of browsers possible, including mobile devices and game consoles (depending on what type of rich media you embed in your courses).

Until e-learning development tools offer greater content flexibility and create courses that adhere to best practices for web design and accessibility, I heartily recommend using standard web development tools in place of specialized e-learning development tools.


Web sites built for any federally-funded project are required by law to meet a certain standard for accessibility. So why don’t we ever hear anyone talk about accessible online courses? No matter how well you think you may know your audience, don’t ever think it’s reasonable to assume no one with special needs will ever take your course.

Accessibility is imperative for a certain percentage of people. It’s a complete downer for another segment of the population, who think making a web page accessible means making the web page boring and free of any rich media. Perhaps this used to be a fair assessment, but not anymore. Many good people have put in long, hard hours making formats such as Flash SWFs and Adobe PDFs more accessible. Plus many alternative web browsing devices can now parse JavaScript, enabling some JavaScript-heavy sites to maintain a reasonable degree of accessibility (disclaimer: it really depends what you’re trying to do with the JavaScript).

What’s even better is that web standards have finally taken root over the last half-dozen years, enabling manufacturers of alternative web browsers to improve their handling of the modern web page. This means that adhering to web standards will take most of the effort out of making your site accessible! You may need to tweak a few things here and there, or put some extra effort into improving the quality of the accessibility — specialized CSS, a little extra markup, and descriptive text are good starting points — but you will have at least met a basic level of accessibility without even trying. This is way cool.

This is yet another reason why using standard web development tools is a good idea, and using e-learning-specific authoring tools may not be the perfect tools their marketing departments would have you believe.

e-learning authoring tools need an overhaul

I understand that it is simply not reasonable to expect all e-learning developers to learn code and create courses using web standards. In my experience, many self-described “e-learning developers” are either instructional designers who know very little about web development beyond using a WYSIWYG editor like FrontPage, or are web developers who know little about instructional design. “Dabblers” are the norm, and I accept it.

With such a large number of non-technical people in what is largely a technical endeavor, who can blame the non-techies for wanting to use an e-learning authoring tool? They’re cheap, they’re easy, and — most importantly — they get the course out the door. The demand is there and is undeniable. Everyone wants better tools that will make their lives easier, even me.

But we can make these tools better. MUCH better. And these better tools can lead to better courses. That’s what we ALL want, right? Isn’t that why we’re in this business?

Based on what I’ve seen, the e-learning tools industry needs to shape up and provide better solutions for its customers. Here are some suggestions.

Make your tools adhere to web standards and best practices.

Make accessibility easier

When creating courses using your product, why not include tools and gentle guidance that aids the developer in making the course more usable and accessible? For instance, you could prompt users to enter descriptive text for any image imported into the course. You could have a warning appear if the user writes a sentence in all capital letters. You could have a tip appear informing the user that the table they just imported should have a long description, and should only be used for tabular data.

Use better markup and styling techniques

Speaking of tables, the documents created by your tool should never use tables for layout! Adherence to web standards means all page styling (fonts, color schemes, etc.) should be handled by external CSS, not inline styles or deprecated font tags. You should also use JavaScript sparingly, and as unobtrusively as possible. Let the page markup (HTML) and styling (CSS) do as much of the work as possible. Avoid browser-specific code, such as Microsoft’s ActiveX, like the plague.

Allow users to export their content into easily reusable formats

If your tool adheres to web standards, it should be easy to export (most) course content to a reusable format such as XML. Allowing users to export their content to XML in turn allows the user to easily repurpose the content for different media, such as importing it into a print-based document format such as Adobe FrameMaker, using server-based conversion tools to create dynamic on-demand PDFs, or syndicating the content via RSS feeds.

Give the developer more flexibility — and encouragement — to try instructional design approaches your design team may not have thought of.

Many courses are designed to be page-turners with a few interactions scattered around. I’ll admit I’ve created my fair share of these courses. Tool manufacturers often promote their built-in templates as meeting or exceeding well-established instructional design principles. Entry- and mid-level developers in this field may actually believe your marketing spiels, and think that your templates are the holy grail. This may be good for your business, but it certainly isn’t good for the person taking the course.

Why not build more navigation and format flexibility into your tool, encouraging the user to think outside the box? Remind the user that your templates are just starting points and the real power of your tool is the flexibility it provides. Adobe Captivate’s success with its branching feature is a good example of how hungry developers are for alternatives to standard, page-tuner-style linear navigation.

Wrapping this thing up

Getting back to BJ’s original question, I use custom home-grown course solutions. This isn’t for lack of wanting a good all-round e-learning authoring tool; I just think there isn’t one out there that meets my needs yet. And until there is, I feel more confident working with standard HTML, throwing in the occasional Flash or Captivate file. I recommend this approach to others because I think it’s the most browser- and platform-neutral method, and opens up the development environment to any web developer without requiring expertise in a niche (and ultimately limiting) e-learning authoring tool.

What do you think?

Wow, OK, I sure didn’t intend to write this much. As you can see I had a few things I’ve been wanting to get off my chest for a while. If you’ve made it this far, you must be interested in this topic, too, so I ask you to kindly let me know what you think. Am I off-base here or what?

A revised SCORM API wrapper

I’ve been a longtime user of the ADL wrapper (with code from the late Claude Ostyn), and to be honest, it’s pretty much met my needs. But I was never completely comfortable with the wrapper for two reasons: 1) The code is hard to read with confusing and overly complicated looking variable names, and 2) the code made heavy use of global variables, which in this Web 2.0 world is a big no-no. Global variables can easily cause conflicts with other scripts and script libraries, and should be avoided as much as possible.

This past week I decided to roll up my sleeves and make a new SCORM API wrapper that takes care of these issues. [ Download wrapper | Documentation ]

Examples of the wrapper in action

I have successfully tested the wrapper with the ADL test suites for SCORM 1.2 and SCORM 2004 rev 3.

Update April 23, 2008: all downloads and demonstration files have been relocated. See the SCORM page for more info.


Now, mind you, I’m not saying the wrapper is perfect — there are still some changes I’m considering — but I think it’s a step in the right direction. I’d love to hear your thoughts on the revised wrapper, especially if you’ve had a chance to test-drive it.

What’s a wrapper?

A “SCORM API wrapper” is a buffer (aka ‘proxy’ or ‘middleman’) that prevents your SCORM course from making direct calls to the SCORM Run-Time Environment (RTE) located on your learning management system.

(For those less familiar with the concept of APIs: API stands for “application programming interface.” An API allows 3rd party developers to tap into specific features of a program or service. For instance, Flickr has become famous for allowing independent developers to create web-based applications that tap into Flickr’s photo hosting services using the Flickr API.)

Why use a wrapper?

There are two really good reasons to use a SCORM API wrapper: 1) advanced error-checking, and 2) ease of maintenance.


If you try to make a call to the SCORM RTE before the course has been initialized (turned on), your call will fail. This means if you try to request the course status or student’s name, your request will not work, and you will most likely NOT receive any error messages telling you what happened.

//This will fail silently if you don't use error-checking
var myvalue = api.GetValue("cmi.suspend_data");

By using a wrapper, you can build ‘checks’ into your code that ensure certain criteria are met before performing a specified action. For instance, the wrapper can ensure your course is properly connected to the SCORM RTE before asking the RTE to give you data.

if (connectionIsActive){
   var myvalue = api.GetValue("cmi.suspend_data");

You can also add debugging alerts and statements to help you figure out what has happened when something goes wrong:

if (connectionIsActive){
   var myvalue = api.GetValue("cmi.suspend_data");
} else {
   alert("api.GetValue() failed because the API connection is inactive.");


Another great reason to use a wrapper is ease of maintenance. The SCORM RTE has been steadily evolving over the years; for the last few years, the dominant version has been 1.2. However, version 1.3 (later renamed “2004”) has been gaining ground, thanks largely to mandates by the US military that require all e-learning courses used in military training be SCORM 2004-conformant. That’s a LOT of courses, and those big-money contracts are increasing the pace of SCORM 2004 support in both courseware and learning management systems.

What if you hard-coded your SCORM 1.2 calls into your course? SCORM 1.2’s nomenclature is very different from SCORM 2004. This means you’d have to dig into all of your courses and replace every single SCORM 1.2-specific reference to the newer SCORM 2004 nomenclature. Yuck.

What would be easier is using a wrapper to control the SCORM nomenclature for you. Consider this SCORM 1.2 call wrapped in a custom function:

function saveData(){

When you change your course from SCORM 1.2 to SCORM 2004, all you’d need to do is change the call in the function from api.LMSCommit("") to api.Commit(""). The code used in your course would be the same (saveData("")), and you’d only need to update your code in one place. This makes upgrading much less painful.

OK, I’m sold on the value of wrappers. Where do I get one?

Chances are you’re already using a wrapper, but probably not to its potential. The ADL has some sample wrappers available on their website, and most commercial SCORM products come with wrappers.

My revision to the ADL wrapper is intended to make it even easier to use and troubleshoot. Best of all, it’s free. 🙂 Give it a whirl! All I ask is for you to give me some feedback; let me know if it works on your particular LMS, or if you have suggestions for improvements.

Update: all demonstration files have been relocated. See the SCORM page for more info.