What feature is missing from your e-learning development tool?

I have some simple questions I’d love to get feedback on.

I’m curious about what people are looking for in their e-learning authoring tools, specifically:

  1. What feature is your current tool missing that you would love to see implemented? Support for team collaboration? Support for themes or custom CSS styling? Support for language localization? A beer dispenser? Etc.
  2. What feature does someone else’s tool have that you’re jealous of?

For me? I wish the most popular tools (Captivate, Articulate, Lectora, etc.) would output cleaner HTML and JavaScript. I also wish there was less reliance on Flash and PowerPoint. But if you read my blog regularly, you probably already knew that!

Please post your opinion in the comments below, and please ask others to give their 2 cents. (You can also reply via twitter if you prefer)

I’m really looking forward to your comments. Thanks!

Advertisements

The pipwerks forum is dead, long live the new eLearning Technology and Development Google Group!

A year ago this week, I launched the not-for-profit and ad-free pipwerks E-Learning Development Forum. It was mostly intended to be a way for me to answer questions about some of my projects, such as the SCORM API wrapper, SCORM ActionScript classes, and my many Captivate hacks. The forum wasn’t a vanity project so much as an attempt to avoid email… I’d rather post answers online where everyone can see them than reply to individual emails. I had also hoped other people in the e-learning community would get involved and ask/answer questions beyond the scope of my pipwerks projects.

Now that a year has passed, I decided to step back and evaluate the success of the forum. The numbers aren’t bad: over 200 members, over 550 posts. Of course, it isn’t about the numbers, but about helping people; I’d like to think that most of those 200 people found the answers they were looking for. This is great, and makes me happy. If I helped even one person, the forum can be considered a success.

However, I also noticed a considerable lack of participation from others. Aside from a few helpful folks, I wound up answering most of the questions myself. This means it wasn’t so much a forum as an “Ask Philip” column. Not exactly what I had in mind.

When combined with the effort it takes to maintain a website (security patches, compatibility issues, styling, etc.), the forum started to feel more like a weight on my shoulders than anything else. So, as of today, I have closed down the forum and moved over to a Google Group: the eLearning Technology and Development group.

I’ve been using Google Groups for over a year with the SWFObject Google Group and Aaron Silvers’ Flash For Learning Google Group (no longer online). It isn’t a perfect system, but I’ve learned to enjoy its simplicity. It’s also free and relieves me of administrative hassles such as applying updates and backing up data. Sweet. Plus you can use Google Groups via email, which means you never even need to visit the site. Bonus.

I’d like to say thank you to all the people who posted in the pipwerks forum, and invite you to join me in the new eLearning Technology and Development group.

I’d also like to ask anyone and everyone who develops e-learning to drop by and sign up for the eLearning Technology and Development group. Ask questions — lots of questions — and let’s see if we can get a good community going!

PS: If you’re wondering why I bothered creating a new group considering there are many other discussions groups/forums out there, the answer is simple: no product favoritism and no advertising. Product forums by vendors such as Adobe and Articulate are focused solely on their products, while bulletin boards by organizations such as the eLearning Guild tend to have a ton of ads and a focus on their events and sponsors. I’d like less clutter in my life, and a simple Google Group (even with the AdSense ads) is a nice clean way to handle discussions. Hope you agree!

Lines in the sand

Before I get to my point, I’d like to give you some background information.

For better or for worse, I’m something of a perfectionist. I’m also something of an idealist; this combination makes life very difficult sometimes. When I embark on a project, I’m usually driven by an innate desire to do it the “right way.”

Before coming to the e-learning world, I worked with print publishing and radio production for about a decade. These are excellent fields for perfectionists! Print production allowed me to work with extreme precision, down to a pixel (actually, a point: 12 points in a pica, 6 picas to an inch!). Radio broadcasting requires precision to a second; there is no room for mistakes. I thoroughly enjoyed the challenges presented by both fields, and, though I didn’t realize it at the time, I enjoyed the constraints: things were black and white, right or wrong, no in-between. Lines were drawn in the sand, cross them at your own peril.

When I went to grad school, I majored in Education, specifically the Instructional Technologies program. In grad school, students are taught instructional design from a ‘best case’ point of view. An idealist point of view, with an emphasis on always performing a thorough analysis of the situation, followed by the implementation of a well-designed solution, followed by lots and lots of evaluation. This was the right way to do things. The line in the sand was clear: skip these steps at your own peril.

Instructional design: the right way or the realistic way?

Being an idealist, I eagerly bought into what was being covered in grad school. I believed (and still do, to a point) that every project should follow ADDIE or a similar model. C’mon, it makes sense, doesn’t it? Again, the line in the sand had been drawn: skip these principles at your own peril.

Now that I’ve spent a few years working full-time as an instructional designer-slash-e-learning developer, I’ve learned first-hand that the instructional design ideals taught in grad school are quickly thrown out the window when you get a ‘real’ job. The most common culprits are time and money, but sometimes it’s managerial ignorance or politics, too.

I’ve witnessed that most training departments don’t do any post-implementation evaluation. It’s not for lack of desire, they simply don’t have the time and/or resources. “Well, they at least do a thorough analysis of the problem, right?” Nope, not so much. An analysis is done, to be sure, but it’s usually pretty quick, and the SME has a pretty influential role in defining the problem, which conflicts with the instructional designer’s main function: define the problem by evaluating the situation and questioning all assumptions, then, if applicable, design a training solution for that problem.

However, many real-world training teams don’t even have an instructional designer, which means the SME carries much more weight. Oftentimes, due to staffing and funding issues, the SME and the trainer are the same person!

And thus the world of e-learning development software is born.

The crazy world of e-learning development

A team with an instructional designer, given the time and resources, would probably not use most of the e-learning development tools on the market because of their inferiority. A much more mature and robust e-learning course can be created by a tandem of an instructional designer, technical writer, graphic designer, and web programmer. But who in this world of downsized training budgets has the funding or time to build a team of experts to create these highly customized courses?

Hardly anyone.

So e-learning development products flood the market, and suddenly SMEs are empowered to create their own professional-looking training materials — fully LMS-compatible! — in a matter of hours. Instructional designers cringe, but the masses have spoken, and they like their newfound abilities!

e-learning development, the right way or the realistic way?

As a perfectionist who is well-versed in the world of e-learning technology, and as a trained instructional designer, I admit I have turned my nose at e-learning development software for a long time. I drew my line in the sand, as I have been taught by both experience and education, and I knew which side I belonged on.

Assuming you even need a course — job aids, podcasts, screencasts, wikis and online forums may solve the problem without even requiring a course to be built — the right way to build an e-learning course is to follow an ADDIE-style model, with an emphasis on instructional design and evaluation. Your courseware should be as interactive and engaging as possible (without falling victim to adding interactions for interaction’s sake), should incorporate the latest Web and accessibility best practices, and should be SCORM-compliant. Avoid clip art and cheesy stock art whenever possible.

However, many people will tell you the realistic way to build an e-learning course is to use a template from an off-the-shelf e-learning development tool. It will contain limited but easy-to-use interactions, allow you to insert whatever free clipart and/or images you can find on the web, and will lead to a simple, decent-looking course in no time, without hiring a contractor.

You wind up not with a Mercedes or BMW, but a with very functional Ford… it gets you from A to B and well within budget.

I admit I find it hard to argue with the ROI of this approach. Having said that, I have always been highly annoyed by the poor aesthetics and code quality of most of these e-learning development tools. But does anyone else care? No! They don’t look under the hood, they just care that the car starts when they need to drive it. I can’t fault anyone for feeling that way. I would feel that way, too, if I wasn’t the mechanic who puts these buckets of bolts together.

I’ve also had issues with how the cookie-cutter nature of the software tends to lead the user away from instructional design considerations — I wouldn’t be surprised if the trainer creates their e-learning course so quickly that they probably haven’t even done any analysis and assessment before digging into the development work.

But again, I’m finding it harder to say that this approach is wrong. Context is key, and in many of these situations, a brief, quickly built and deployed piece of training (perhaps not even a full course) may be a perfectly suitable solution. Bullet points are not always evil.

Can’t we all just get along?

Yes, I have been questioning the ferocity of my beliefs for some time, and conversations with others (and the e-learning blogosphere) have led me to eventually shift my opinion on the subject: No, lines do not have to be drawn in the sand, and the simple act of drawing them may be more harmful than helpful.

Some of my peers are also re-examining their beliefs and asking questions; I think this is great, since our field is a quickly evolving field. Just today, Aaron Silvers wrote about tactical versus strategic planning [link no longer available]:

Lots of organizations in the last 10-20 years solve problems by looking at the immediacy of issues. The brushfires. The low-hanging fruit.

Aaron wasn’t writing specifically about what I’m writing about, but the line struck a chord with me; putting out fires and trying to grab the “low-hanging fruit” is a primary cause of the explosion of just-in-time training, a large chunk of which is e-learning courseware developed using “rapid elearning” development tools such as Articulate Presenter.

Clive Shepherd is excited about this, saying

One of the really exciting consequences of the web 2.0 revolution is the emergence of all sorts of new learning objects, designed for quick access when you need something that’s just-in-time and just enough.

  • Short videos
  • Slide sets
  • Podcasts
  • Mini e-books

Each of these media can be developed using commonly available tools and skills, something that can’t be said for interactive tutorials. They are better suited than tutorials to performance support applications, where learning is not the primary objective.

I’d like to emphasize two of his phrases: “performance support applications” and “just enough.” Most e-learning is designed to help someone do their job. The learner is a busy person and doesn’t really want to take long-winded courses; s/he just wants to know enough to get the job done. Likewise, most training developers will choose the easiest and fastest way to create these training materials, ideals and theories be damned!

Personally, I feel torn between wanting to satisfy the needs of the learner in the quickest fashion possible, and wanting to present a complete, thorough course using sound instructional design, including needs assessments and evaluations.

Warning: gestalt shift!

I think what this boils down to is that we’re in the midst of a gestalt shift from ‘courseware by professionals’ to a rapid e-learning world (and no, please don’t use the term elearning 2.0!).

If this is a rapid e-learning world where SMEs produce courses, where do the skilled e-learning developers fit in? I believe there’s room for all of us. Clive Shepherd admitted “It’s still quite hard for non-specialists to create good interactive tutorials, even of the rapid variety.”

I recently exchanged emails with Tom Kuhlmann from Articulate, and I really appreciated what he had to say about the topic:

It was just a few years ago that only a few people were able to create those horrible gray web pages with [little] more than text. Now, look at where we’re at. You need no technical skills and with some of the new 2.0 web tech, you can create some pretty impressive stuff.

I’m for anything that democratizes the process and gives people power to develop their own training and whatever else they want to do. Are you going to get perfect courses? No. But that will create a market for those that can produce better stuff.

I think there’s a place for it all, and with that a lot of opportunity for people like you who have good programming skills. You’re able to help the novice ID/SME bring their content up a notch.

Where do professional e-learning developers go from here?

I agree with Tom, but I’d like to take it one step further: rather than “helping the novice ID/SME bring their content up a notch,” I feel it’s the responsibility of professional e-learning developers to pressure the e-learning development tool industry to improve their products to meet higher standards, both in terms of web & accessibility best practices, and in terms of educating their customers on what comprises sound instructional design.

I think there’s an excellent model to follow: In the early- to mid-90s, Adobe and Aldus produced high-quality instructional booklets explaining the print production process from start to finish. These guides were distributed free with the manuals for specific software titles (PageMaker and Freehand). The guides were extremely well-written and illustrated, and taught me a lot about the preproduction and printing process before I ever stepped foot in a print shop.

Why did they supply these free books? I never really found out. My assumption is that a deeper understanding of the print process would foster more skilled use of their software, and a deeper appreciation for its power/capabilities.

The e-learning development tool industry would be wise to follow that lead; educating its customers about e-learning and related topics (ADDIE? Gagne? SCORM? Design principles? Color theory?) can only help to improve the industry as a whole. And as we all should know, if we do a good job, the learner does a better job, and the world becomes a better place.

Development standards for e-learning… a starting point

Understanding that we should be using standards and best practices throughout e-learning development, the question becomes “what standards and best practices should we follow?”

Here’s my attempt at outlining some basics. Please feel free to suggest additional items in the comments section.

Follow established “web” best practices.

Separate presentation from content as much as possible by using Cascading Style Sheets and semantic (X)HTML markup.

  1. Use classes instead of inline styles or font tags.
  2. Avoid tables for layout purposes, except when presenting tabular data.
  3. Keep your markup semantic by properly using available elements: h1, h2 and h3 for headings, p for paragraphs, div for block-level content divisions (similar to fieldset in forms), and span for inline classes. Don’t be afraid to try lesser-known elements such as acronym for acronyms, dl for definition lists, and cite for citations!
    1. Note: although div is heavily used in CSS-based layouts, you should try to avoid overuse of the div element. Bloated markup is unsemantic and ugly.
    2. Avoid direct copying and pasting from Microsoft Office products, as this tends to insert bloated Microsoft-specific HTML.
  4. Avoid deprecated or browser-specific elements such as blink and marquee.

Separate behavior from content as much as possible by using unobtrusive JavaScript techniques.

Even if your course depends on JavaScript being available, this is a good practice to follow.

  1. Don’t use inline scripts. Keep all scripts in the head of your document or in an external .JS file.
  2. Use a lot of error checking throughout your scripts. This helps ensure that if an error occurs, your script should fail gracefully, and you should be able to diagnose the problem more easily.
  3. Avoid using JavaScript where it isn’t needed. CSS is capable of handling many chores once assigned to JavaScript, such as image-based mouseovers and “hover” or “dropdown” menus. CSS has the added bonus of processing the chore much faster than JavaScript, too!
  4. Avoid using the global space. With the proliferation of JavaScript in our “Web 2.0” world, web pages use multiple script libraries and customs functions. Avoiding using the global space by using faux “namespacing” (object literals) can greatly reduce the odds of your script conflicting with another script.

Avoid plugins and browser-specific technologies as much as possible

  1. Don’t use Microsoft’s ActiveX or the Windows-specific FSCommand. Stick to cross-browser and cross-platform solutions.
  2. Avoid Java and any other format that requires a plugin, especially one that requires a large download. Flash Player may be the only exception due to its incredibly high saturation rate, but even then you should plan ahead in case users don’t have Flash Player available.
  3. If a plugin is required, especially an unusual or uncommon plugin, be sure to notify the user of the requirement before they launch the course.

Keep content as accessible as possible by following established accessibility best practices.

  1. Avoid tables for layout purposes, except when presenting tabular data.
  2. Avoid using images for important navigation elements. Your markup will be cleaner (and you’ll be separating your style from content) by sticking to text-based navigation links. Don’t worry — you can still use images by utilizing CSS image replacement techniques! If you decide to use images in your markup, be sure to include useful descriptive text in the alt attribute.
  3. Be aware of tab order; don’t mess with the tab order of page elements unless it’s absolutely necessary.
  4. If your page contains lots of navigation menu items, give the user a ‘skip navigation’ option. This is especially important for people who use screen readers.
  5. Ensure links contain useful text such as “Click here to continue” or even “continue,” not the more obscure “click here.”
  6. Heavy use of onmouseover and onclick in JavaScript can cause problems for people who don’t use a mouse (many people use their keyboard for all navigation purposes). Be aware of the repercussions of your coding techniques.
  7. Try testing your course in a popular screen reader such as JAWS.
  8. Rich media such as Flash videos are fine to use in your course. However, there are some simple steps you can take to ensure your Flash content is as widely accessible as possible:
    1. Use fallback (popularly known as “alternate”) content in your HTML in case Flash is not available. For instance, if your page contains a Flash video, include a text transcription in the HTML. When Flash isn’t available, display this transcription automatically (SWFObject is great for this purpose).
    2. If using video, screencasts, or any other media that contains audio narration, include a closed-captioning option or a link to a text transcription.
    3. Adobe has made strides to make Flash SWFs more accessible. Keep up with the latest trends, and use Flash best practices to ensure maximum accessibility.

Keep your courseware portable.

  1. Avoid server-side dependencies such as Active Server Pages (ASP), PHP, and databases.
  2. Use standardized LMS communication protocols such as SCORM and AICC. Avoid using proprietary course-to-LMS communication methods as they make content migration and reusability a very difficult task.
  3. Avoid using remote content if possible. Some systems may not be able to access the remote content due to security or connectivity issues, which could lead to a broken course.

Ensure your course has a long shelf-life and is easily maintainable.

  1. Avoid uncommon development platforms and/or proprietary file formats whenever possible. This ensures your content will remain editable for the foreseeable future.
  2. Clearly annotate/document your development process and home-brewed scripts. This ensures future team members and/or contractors will be able to work on the project if needed.
  3. If you compile or compress your files, be sure to keep a commented, uncompressed copy of each file with your development files. This applies to both JavaScript and Flash-based projects.

What do you think?

Let’s have a conversation about this. I’m 100% positive I’ve missed a few things, and I’m pretty sure not everyone will agree with my statements. Why not join in and add your two cents? I’ll leave the comments section for this topic open indefinitely.

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.

Rapid Intake: Where are the standards?

Today Rapid Intake announced a new service named Unison.

Not having used the service, I won’t pretend to know whether it’s a worthwhile service or not. It’s certainly an intriguing idea, and with its oft-mentioned low price, it’s guaranteed to get some industry buzz.

Out of curiosity, I perused the Rapid Intake site to read more about Unison. I wasn’t very impressed with the Unison product webpage. Being the geek I am, I decided to take a peek at the Unison page’s source code. UGH! They’re using tables for layout, JavaScript for simple navigation menu mouseovers, are omitting alt tags on many images, are using non-web-safe fonts, and are positively abusing CSS styles by applying a class called “maintext” to almost every paragraph.

Here’s a snippet:


<tr>
<td height="310" valign="top" class="h1">
<p class="h1">Collaborative eLearning Development and
Review for Teams</p>
<p class="h1"> </p>
<p class="mainText">Built on the Rapid Intake eLearning 
Development Platform, Unison is a web-based solution 
[ ... ]</p>
<p class="mainText"> </p>
<p class="mainText">Now all your SMEs, designers, 
and reviewers can work together on e-learning courseware 
[ ... ]</p>
<p class="mainText"> </p>
<p class="mainText">All you need to do is <a href="#">logon and get started.</a> </p>
<p class="mainText"> </p>

This code clearly demonstrates a lack of understanding of long-established web standards and best practices.

I certainly don’t mean to beat up on whoever designed their site, but as a company whose business is publishing web-based documents, this website gives me zero confidence in the quality of their product.

Please understand that I’m not trying to be a jerk here. I wouldn’t rag on an individual person’s site or home-brewed course system (I know my site isn’t perfect, either!). It’s just that this site is a perfect example of how our industry appears to pay little heed to web standards and best practices. Rapid Intake — a company clearly on the rise in our niche market — is in a perfect position to be a role model for ‘doing it right.’

Standards make development work easier, and greatly reduce compatibility issues. I just don’t understand why companies like Rapid Intake don’t see that.

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.

Accessibility

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?

Loading Captivate files into an AS3 Flash SWF

Update April 7, 2008: I’ve written a new AS3 class named LegacyCaptivateLoader that uses ExternalInterface to bridge the AS3 SWF and the Captivate SWF. Check it out.

I guess I’m late to the party, but I only recently realized that although a Flash Player 9 SWF can load an older Flash Player 6/7/8 SWF, it can’t communicate with it.

(In my defense, since we haven’t really started using ActionScript 3 at work yet, I’ve been a bit slow in switching to AS3. The leap from AS2 to AS3 is pretty daunting, so I’m sure I’m not the only one dragging my feet!)

Turns out the mechanism that processes the ActionScript (the ActionScript Virtual Machine, or “AVM” for short) has been rebuilt. Flash Player now ships with two unique ActionScript processors: AVM1 for legacy ActionScript 1 & 2 SWFs, and AVM2 for ActionScript 3 SWFs. Without getting overly technical, this enables AVM2 (Flash Player 9 SWFs) to be exponentially faster than AVM1 (Flash Player 8 and lower SWFs).

As you can imagine, many Flash developers — like you and me — still need to load old SWFs into a new Flash Player 9 (ActionScript 3) user interface. For instance, many Flash-based e-learning courses load ‘content’ SWFs that were created a couple of years ago with Flash MX (7) or Captivate. No one wants to recreate or republish a few years’ worth of development files.

To accommodate people who still need to use their older SWFs, Adobe configured Flash Player to allow AMV2 SWFs to load the older AVM1 SWFs in a virtual sandbox. But, as I mentioned, there’s a catch: these AVM1 SWFs cannot communicate with the parent AVM2 SWF.

This is a very big problem for many Adobe Captivate users. Adobe didn’t wait for the Captivate development team to convert Captivate to AS3, which means Captivate users are still publishing AS2 SWFs on a daily basis. A large number of Captivate users ‘play’ their Captivate files in custom Flash-based course interfaces. If they want to use a newer AS3 interface to control their Captivate SWFs (play, pause, etc.), they’re out of luck.

I guess you can’t blame Adobe for not updating Captivate’s codebase; Captivate has probably had the same codebase since early versions of RoboDemo, and converting to AS3 would probably require a complete overhaul of the product. No small task.

The Experiment

Anyway, I’ll get to the point: I researched the different methods available for AVM1 to AVM2 communication, and discovered there are a few workarounds that can enable the AS3 SWF to communicate with the AS2 SWF. I spent the entire day whipping up a Captivate-specific proof-of-concept, which can be viewed here.

For this experiment, I used LocalConnection. I’ve also been researching an ExternalInterface method, but the LocalConnection method was much easier to implement and doesn’t require JavaScript.

Because LocalConnection requires the old SWF to have specific LocalConnection code inside it, we can’t use LocalConnection on Captivate SWFs without a little help. I was able to use a proxy SWF to load the Captivate movie.

I’m not ready to explain the code and hand out the source files, but I hope this proof of concept can help others out. The short version is:

  1. A ‘player’ SWF (AS3) loads an AS2-based ‘proxy’ SWF. This proxy SWF is configured with custom LocalConnection settings allowing it to send and receive commands from the AS3 player.
  2. The proxy SWF loads the Captivate SWF. Since the proxy SWF and Captivate SWF are both AS2, they can communicate with each other using the famed ‘Captivate variables’.

Thus the AS3 SWF sends instructions to the proxy SWF, which relays the instructions to the Captivate SWF. Conversely, the Captivate SWF sends data (frame count, current slide, etc.) to the proxy SWF, which then sends the data via LocalConnection to the AS3 SWF.

BTW, using LocalConnection to bridge AVM1 and AVM2 isn’t an original idea… many people have blogged about these concepts over the last year or two, and had some good tips (see my references at the end of this post). There are even a few functional commercial and freeware products out there.

I decided to develop my own method out of curiosity, and because most of the existing products are overly complicated, designed to handle way more than my dinky little Captivate files. Plus I wanted to create a system that would have the ‘Captivate variables’ built-in, so it will be plug-and-play with any Flash-based Captivate loader.

Caveats

There are some very big caveats when using LocalConnection to bridge AVM1 and AVM2 SWFs; these caveats are big enough to make me question just how far I want to go with this project.

Caveat #1: LocalConnection is asynchronous. This means it can’t return values, and it may not kick in as soon as you’d hoped. I learned firsthand that LocalConnection worked much faster in my local environment than it did after I uploaded it to the server.

Caveat #2: LocalConnection works independent of the browser, and can only have ONE active connection per unique LocalConnection session. For instance, if I create a course that uses a LocalConnection named “FlashToCaptivate_LC”, I can only have one instance of that course running on my computer. If I open a second instance of the course, regardless of which browser it’s in, or whether or not the course is local or online, the second course will return a LocalConnection error because the connection named “FlashToCaptivate_LC” is already in use. Think of it as a phone number without call waiting. If someone is on the phone and you try calling, all you’ll get is a busy signal. That’s LocalConnection.

What do you think?

I’d love to hear any feedback you might have about this topic, including whether or not any of you have tried LocalConnection yourselves.

Resources

Here are some good resources/discussions about the topic if you’d like to learn more (no particular order):

A look at Captivate 3.0, part one

Here are my first impressions of Captivate 3’s improvements and new features.

This is part one of a multi-part journal entry.

Importing PowerPoint presentations

Disclaimer: I have never recommended nor will I ever recommend using PowerPoint presentations as online courseware. It’s a bad idea, whether it’s been converted to Captivate or not.

Having said that, Captivate 3 represents a substantial improvement over Captivate 2 when importing PowerPoint (PPT) presentations. In Captivate 2, PPT animations were lost during the conversion, and Captivate 2 didn’t automatically add pauses (‘wait for mouse click’ behavior) in each slide. This meant that every slide became a still screenshot, and the converted presentation would automatically go from slide to slide in a matter of seconds. Users had to add their own navigational aids or use the Captivate playback controls.

Captivate 3, on the other hand, converts PPT animations to SWF format, enabling users to retain most of their PPT animation. I haven’t pushed the boundaries when testing this feature, but for general zoom, resize, and fade-style animations, the SWF version was identical to the PPT version.

One important thing to note about imported PPT presentations: Captivate 3 does NOT import clickable items. For one of my tests, I imported a large PowerPoint presentation that contained clickable items on each page. In this case, the clickable items were all homemade navigation aids, such as next, previous, and menu. Captivate stripped the links from all clickable items and rendered them as non-clickable drawings. Clicking anywhere on the screen — even on what used to be a ‘back’ button — simply caused the Captivate movie to go forward one slide.

Slide Transitions

In Captivate 1 and 2, users only had three slide transitions to choose from: fade in, fade out, and fade between. Captivate 3 has swiped emulated PowerPoint’s array of transition types, including blinds, fly, iris, photo, pixel dissolve, rotate, squeeze, wipe and zoom.

In the name of all designers who create items of taste, I implore you to ignore these new transitions unless they make sense for your particular needs. For most cases, I say less is better. There are some exceptions; for instance, if you’re recreating scenes from Star Wars and want that famous wipe transition between scenes, go for it! Or the iris transition for a James Bond-themed Captivate movie. Otherwise, most of these transitions are intended to appeal to the PowerPoint crowd, and are best left alone.

I’m not a Mac evangelist by any means (I use Windows XP), but if you want to see some very tasteful transitions, check out a demo of Keynote sometime. It’s enough to make me want to buy a MacBook Pro.

Why Adobe chose to emulate the worst-of-class PowerPoint transitions and ignore the best-of-class Keynote transitions — which are perfectly suited for a SWF — is beyond me.

Stronger Captivate branding

It seems Adobe is trying a little harder to spread the Captivate brand name around. The default playback controller now includes an “Adobe Captivate” stamp. This is only on the default skin, so you can easily choose another skin if you don’t like giving Adobe free advertising.

Adobe has also added a new Adobe-branded preloader graphic. The previous default was a small circle spinning around. The new default is a progress bar with the text “Adobe Captivate” placed in bold right above the bar. Again, free advertising for Adobe if you don’t want to change the defaults. If you don’t like the Adobe branding, you can choose a different preloader graphic, just like Captivate 2.

While I’m not crazy about this branding being set as the default, I also acknowledge that Adobe’s competitors have been doing it for years, and many of them won’t give you an easy way to remove their logos (hello, TechSmith). So long as Adobe keeps the branding optional, I’m ok with it.

Up next

In part two, I’ll take a look at the new Question Pool feature, as well as the LMS export options.

Captivate 3, JavaScript and Actionscript

I just got Captivate 3, and eagerly installed it to see if any improvements have been made regarding JavaScript and Actionscript handling. Short answer: nope.

Javascript

According to Captivate’s ‘Help’:

You can add JavaScript to click boxes, text entry boxes, and buttons in Adobe Captivate projects. The JavaScript can run when a user clicks inside or outside the box or button. Using JavaScript gives you the opportunity to extend projects in numerous ways while adding interactivity.

Same as before.

Actionscript

Absolutely zero changes from what I can tell.

Unfortunately, this means my previous comments regarding using JavaScript and Actionscript in Captivate movies still stand.

I plan to post a brief review of Captivate 3 shortly.