DRAFT 0.8 
Cooking up a SCORM 
A SCORM 1.2 Content Cookbook for Developers 
Version 1.2 – Draft 0.8 
Claude Ostyn 
Learning Standards Strategist 
Click2learn, Inc. 
Converting pdf to open office - control software platform:C# Create PDF from OpenOffice to convert odt, odp files to PDF in C#.net, ASP.NET, MVC application
Enable C#.NET Users to Convert OpenOffice Document (Odt, Ods, Odp) to PDF
www.rasteredge.com
Converting pdf to open office - control software platform:VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF in vb.net, ASP.NET, MVC application
How to Convert OpenOffice Document (Odt, Ods, Odp) to PDF with VB.NET Demo Code Samples
www.rasteredge.com
ii
Copyright and Terms of Use 
Copyright ©2002-2003 by Click2learn, Inc. - All rights reserved. 
This White Paper is a Click2learn Standards Project, subject to change. Permission is hereby granted for Click2learn 
customers and contractors, and for participants in industry standard initiatives, to reproduce this document for purposes 
of standardization services, including balloting and coordination. If this document or any part of this document is to be 
submitted to any standards body, notification shall be given to the Click2learn Copyrights Administrator. Other entities 
seeking permission to reproduce portions of this document, for these or other uses, must contact the Click2learn 
Copyrights and Permissions Department for the appropriate license. The publication of this document does not imply 
that Click2learn, Inc. intends to implement any of the functionality described in this document. Click2learn, Inc. reserves 
the right to modify this document and its annexes, as well as any other specification, product or offering without notice. 
Click2learn, Inc. assumes no responsibility for any error that may appear in this document. Click2learn, Inc. makes no 
commitment to update nor to keep current the information contained in this document. Use of any information contained 
in this document is entirely at your own risk.  
Click2learn Copyrights and Permissions 
110 - 110
th
Ave NE, Suite 700 
Bellevue WA 98004 
USA 
Point of contact for questions and comments: 
Claude Ostyn 
Claude.Ostyn@Click2learn.com
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
control software platform:C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
C#.NET Tutorial for Converting PDF to Word (.doc/ .docx) Document with .NET XDoc.PDF Library in C#.NET Class. Best C#.NET PDF to Microsoft Office Word converter
www.rasteredge.com
control software platform:VB.NET PDF Converter Library SDK to convert PDF to other file
This guide give a series of demo code directly for converting MicroSoft Office Word, Excel and PowerPoint document to PDF file in VB.NET application.
www.rasteredge.com
iii
Contents 
Copyright and Terms of Use............................................................................ii
Introduction.......................................................................................................1
Overview.......................................................................................................1
Audience and purpose.................................................................................1
What about SCORM 1.3?............................................................................1
About authoring tools...................................................................................2
About the examples.....................................................................................2
Chapter 1 -
Overview of SCORM.................................................................3
What is SCORM?.........................................................................................3
What is SCORM-compliant learning content?............................................3
Organizing learning objects and SCOs.......................................................5
Implementing SCORM-compliant learning objects and SCOs..................6
Chapter 2 -
Basic SCO behavior..................................................................7
Chapter 3 -
Building simple SCOs.............................................................10
Building the simplest SCO.........................................................................10
A generic script for simple SCOs..............................................................11
Chapter 4 -
Your SCO as a Web page......................................................13
Chapter 5 -
Turning any browser compatible resource into a SCO..........14
Chapter 6 -
Building a Multiple-page SCO.................................................17
Three methods to persist state in multiple-page SCOs...........................17
Using a frameset for a multi-page SCO....................................................17
A complete example..................................................................................18
Chapter 7 -
Managing SCO state and communications............................20
A more complex reusable SCO script.......................................................20
A more complex SCO that reports tracking data when it is unloaded.....25
A more complex SCO that reports tracking data as it occurs..................27
The ambiguities of status...........................................................................28
How and when to set status information...................................................28
Chapter 8 -
A layered architecture for SCOs.............................................29
Chapter 9 -
Suspend and resume..............................................................30
A multi-page SCO that can be suspended at any page...........................30
Chapter 10 -
Tracking objectives within a SCO.......................................34
Chapter 11 -
Displaying a SCO in full screen mode................................39
Chapter 12 -
Packaging SCORM-compliant content...............................44
Appendix: Miscellaneous resources and implementation notes...................46
Sequence diagram.....................................................................................46
Sample SCORM 1.2 package manifest....................................................49
About the author.............................................................................................52
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
control software platform:VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
Microsoft Office Word 2003 (.doc), 2007 (.docx, .docm, .dotm, .dotx) and later versions are compatible with this VB.NET PDF Converting DLLs for PDF-to-Word.
www.rasteredge.com
control software platform:C# PDF Converter Library SDK to convert PDF to other file formats
This PDF document converting library component offers reliable C# supports file conversion between PDF and various and images, like Microsoft Office (Word, Excel
www.rasteredge.com
1
Introduction 
Overview 
The Shareable Content Object Reference Model (SCORM), published by the Advanced 
Distributed Learning (ADL) project, is a de facto standard for e-learning content. This 
document describes how to create Web-based content that complies with the SCORM 1.2 
specification. Like the SCORM specification, this is a technical document, not an instructional 
design document. Like SCORM, it does not deal with the instructional quality of the content, 
but with the features that are necessary to make the content portable and conforming to the 
SCORM. The document uses functioning examples to illustrate various aspects of the 
SCORM specification. 
This document is divided into several chapters. Following a brief overview of SCORM, each 
chapter builds on the basic SCO model to build progressively more capable and complex 
SCORM-compliant learning objects. Finally, a chapter reviews the basics of packaging--how to 
assemble the learning objects into a SCORM-conformant package that can be migrated and 
deployed on any compliant delivery system. 
Audience and purpose 
If you are already using a fully SCORM 1.2 compliant authoring tool or development 
environment like ToolBook or Aspen 2.1 LCMS, you probably do not need this document 
although its introduction may be useful to understand the underlying technology and rules. 
Depending on your purpose and interest, you may read this document in different ways: 
‰ 
As a companion to the SCORM specification, to get a better idea of what is and is not 
covered by that specification and see examples of how it can be applied in content. 
‰ 
To understand various technical aspects of the SCORM specification through examples. 
‰ 
As a technical guide with a set of examples that may help you save time in the actual 
implementation of content. 
This document is intended for content developers with different levels of technical expertise. It 
may also be useful to instructional designers, quality assurance staff and program managers 
who want to understand better what SCORM 1.2 enables and makes difficult. However, this 
document is aimed primarily at a technical audience with at least some familiarity with Web 
concepts and hands-on basic HTLM and JavaScript experience.   
What about SCORM 1.3? 
Content created according to the guidelines in this document will not automatically be rendered 
obsolescent by SCORM 1.3 or other future specifications because: 
‰ 
SCORM 1.2 is much simpler than SCORM 1.3 and conformance is easier to verify. Since 
there are entire classes of content that do not require the new features introduced in 
SCORM 1.3, it is expected that support for SCORM 1.2 for general content delivery, 
migration and archival will continue for a long time 
‰ 
Robust implementation of SCORM 1.3 conformance in commercial products may take 
anywhere from 3 to 24 months, if the history of SCORM 1.2 is any guide 
‰ 
Systems that support SCORM 1.3 content are expected to also support SCORM 1.2 
content, either directly or through the use of a generic adapter 
‰ 
This document describes a layered approach that allows wholesale upgrades of SCORM 
content object from 1.2 to 1.3 compliance just by upgrading one or two generic script files 
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
control software platform:VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
image to PDF, C#.NET convert open office to PDF VB.NET PDF - Create PDF from Microsoft Office Excel in VB.NET Tutorial for Converting PDF from Microsoft Office
www.rasteredge.com
control software platform:C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Best C#.NET PDF Converter SDK for converting PDF to HTML in Visual Studio .NET. This is a C# programming example for converting PDF to HTML.
www.rasteredge.com
2
An update of this document is planned for release after the final SCORM 1.3 specification is 
released in late 2003. The plan includes a section that will explain how to update content 
created according to this document to be SCORM 1.3 compliant. 
About authoring tools 
The authoring tool used to develop the examples in this document is a simple text editor. 
However, these examples are not populated with the rich content and interactions that a real 
authoring tool can facilitate. A tool such as Click2learn's Aspen 2.1 Web-based enterprise 
LCMS, or desktop authoring tools such as Click2learn's ToolBook 8.6, does much of what is 
described in this document automatically: You just specify that you want to export the content 
as a SCORM package and it will do it for you. Those tools are designed specifically to isolate 
you from the technical minutiae described in the SCORM specification and in this document, 
so that you can focus on what your content shows, tells and teaches.  
For example, Aspen Learning Content Management Server (LCMS) is a global, scalable, 
100% Web-based application that enables rapid creation, delivery and management of high 
quality learning content for your entire enterprise. Aspen LCMS is designed to facilitate the 
separation of presentation, logic and behavior in learning objects, providing maximum flexibility 
and reusability. The team-based authoring environment allows concurrent development, 
allowing instructional designers, subject matter experts, project managers, and reviewers to 
work together to create high quality courses quickly. In this big picture, SCORM conformance 
plays a small part, although it is a critical one.  
Note that if when you use ToolBook, Aspen LCMS or another SCORM-conformant authoring 
tool or content generator to create the content, the actual code and Web document structure 
those tools generate will be quite different from what is described in this document. There are 
many ways to achieve SCORM conformance, which is good because it leaves a lot of room for 
creativity. 
About the examples 
The examples in this document illustrate how content that conforms to the SCORM 
specification can be implemented. You may use any of the code included in the samples 
described in this document but, if you do, proper credit should be given to Click2learn, Inc., 
including a reference to this document. If you choose to reuse any of the sample code, it is 
entirely at your own risk. The sample listings and the code in the companion files in working 
examples are not intended to be actual production code and do not represent that Click2learn 
is actually implementing such code in its products. Some code and features that could be 
useful in an actual product were deliberately not included because they are considered 
proprietary, or trade secrets of Click2learn, Inc. In particular, error handling is minimal in order 
to keep the sample listings brief. The exhaustive testing that would normally be done for actual 
production code, using all the browsers in common use, has not been performed on most of 
these samples. The examples have been tested with Microsoft Internet Explorer 6.0 and with 
the SCORM 1.2.3 test suite, and should work with other browsers and versions, but "your 
mileage may vary." It is highly recommended that you keep the SCORM 1.2 specification 
handy for reference as you work your way through these examples. 
Your own implementation, coding style and policies may be completely different from what is 
shown here. However, that should not prevent them from conforming to SCORM and 
interoperating predictably with other SCORM conformant systems. That is the beauty of a 
standard. Interoperability is what matters, not how you implemented it.  
The actual example files, as well as the most recent version of this document, may be 
downloaded from http://home.Click2learn.com/standardswork
 
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
control software platform:C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
here is that our PDF to text converting library is Integrate following RasterEdge C#.NET text to PDF converter SDK dlls RasterEdge.XDoc.Office.Inner.Common.dll.
www.rasteredge.com
control software platform:C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
and WinForms applications. Support converting PDF document to SVG image within C#.NET project without quality loss. C# sample code
www.rasteredge.com
3
Chapter 1 - Overview of SCORM 
What is SCORM? 
SCORM is a set of specifications that describes: 
‰ 
How to create Web-based learning content that can be delivered and tracked by different 
SCORM-compliant learning management systems 
‰ 
What a SCORM-compliant learning management system must do in order to properly 
deliver and track SCORM-compliant learning content 
The SCORM specifications are based on various other industry standards and specifications. 
The current official version is 1.2.  
The SCORM specification does not cover all aspects of a learning enterprise; for example, it 
does not specify how tracking information is stored and what reports are generated, what 
pedagogical or training models should be used, or how learner information is compiled. 
SCORM 1.2 also does not specify how content is sequenced by a runtime service. The most 
common assumption is that the user is free to choose any part of the content. Future SCORM 
specifications will define how to specify sequencing behavior for content. In the meantime, 
SCORM 1.2 provides a robust specification for content that can be packaged and migrated 
between systems, installed on an LMS or archived in a plug-and-play manner. 
There is a version 1.3 in the works, which will extend on SCORM 1.2 by specifying how to add 
prescriptions for sequencing. That new version will probably not become final until sometime in 
2003 and content developed to conform to SCORM 1.2 should still be able to function in an 
implementation of SCORM 1.3. 
What is SCORM-compliant learning content? 
In the SCORM 1.2 specification, SCORM-compliant learning content is either—in SCORM 
terminology—a Content Aggregation Package or a Resource Package. A Resource Package 
is a collection of learning assets that is not intended for delivery as such, for example to 
archive or migrate a collection of asset. This document does not describe how to build or use 
Resource Packages; it focuses on deliverable content. A Content Aggregation Package is: 
‰ 
Intended for delivery to a learner through a Web browser 
‰ 
Described by metadata 
‰ 
Organized as a structured collection of one or more learning objects called Shareable 
Content Objects (typically abbreviated as "SCO"
1
‰ 
Packaged in such a way that it can be imported by a compliant learning management 
system or into a repository used by such a system 
SCORM content is made of SCOs aggregated into a content package. The SCOs are a 
specialized type of learning object. Each SCO is a unit of content that can be delivered to a 
learner by a SCORM-compliant learning management system in order to create a useful 
learning experience.  
The SCOs used in a SCORM-compliant package may be fully included in the package, or 
used by reference. For example, under certain conditions a learning sequence may include 
learning objects that reside on another server. Note that the security restrictions implemented 
in Web browsers to prevent malicious cross-server exploits make the use of learning objects 
that reside on another server more difficult. How to solve this problem is an issue for learning 
content management system and content repository vendors to resolve. There is nothing you 
can do in the content itself to work around this security barrier.  
1
"SCO" is commonly pronounced "scō", rather than sounding out the letters as in "ĕs'sē'ō" 
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
control software platform:C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
Best C#.NET PDF converter SDK for converting PDF to Tiff in Visual Studio .NET project. C# programming sample for PDF to Tiff image converting.
www.rasteredge.com
4
Kinds of SCORM learning objects 
A Web-based learning object that can be included in a package for delivery by a SCORM 
compliant learning management system as an individual activity is called a "Shareable Content 
Object" (SCO). In practice, SCOs come in two main flavors:  
‰ 
A minimal SCO. This is HTML content or a service that can be launched in the browser 
window, and uses the SCORM Application Program Interface (API) for minimal 
communication with the learning management system. An LMS can track the time 
between the launch and the normal termination of such an object. Most generic content 
that can be launched in a browser window, but does not contain links to another learning 
object, can usually be turned into a SCO by "wrapping" it into a SCO. This could be an 
HTML page, an Adobe Acrobat file, or a text file. A collection of HTML pages is also 
acceptable, as long as they only link to each other and not to other learning objects.  
‰ 
A data-enabled SCO. This is like a basic SCO, but also uses the SCORM API to get or 
send data to the LMS. The data may include tracking data, learner information, etc. as 
defined in the SCORM 1.2 specification. 
The technical requirements for SCOs will be described in more detail in the technical sections 
of this document and illustrated with examples. 
Online or offline learning objects 
Regardless of how many SCORM features they use, SCORM 1.2 compatible learning objects 
do not communicate across the Web to a remote server. They only communicate with other 
objects within the same browser environment on the client side. The implementer of the 
delivery environment provides that object. There is a well-defined way for the content to find 
that object and communicate with it using simple JavaScript code or its equivalent. This has 
major advantages: 
‰ 
SCOs can be very easy to implement, because they do not need to include the complex 
communication protocol required to send and receive data across the Web. 
‰ 
SCOs can be run in an offline environment without requiring a local Web server or proxy 
server, because they communicate with other local browser objects rather than with a 
server-based object. 
The SCORM API implementation is instantiated on the client side by a runtime service before 
the SCO is launched. This implementation may vary from vendor to vendor. For example, the 
API may be implemented in an HTML frameset that contains a "stage" frame within which the 
learning objects are launched.   
Organizing and sequencing learning objects 
The person or entity that creates a package of learning objects decides how the learning 
objects are organized. However, since SCORM 1.2 does not define any sequencing 
information, the learner will be able to choose which learning object to use and in which order.  
Future versions of SCORM, starting with SCORM 1.3 will add a more advanced sequencing 
model to SCORM 1.2, to allow the implementation of richer pedagogical or instructional 
models. 
SCORM 1.2 uses the IMS Packaging specification as a foundation for the packaging and 
organization of learning objects. A package may contain more than one organization of the 
same learning objects. For example, you could define two or more tracks covering the same 
subject at different levels of depth, or for different audiences. An LMS can take advantage of 
this to allow a choice of the more appropriate organization.  
SCORM 1.2 specifies how to build a package, but it does not specify how an LMS uses some 
optional features of the package such as multiple content organizations. Once the learner, 
manager or learning managements system has chosen an organization within the package, 
however, SCORM 1.2 does specify that the learner must be able to launch each of the 
learning objects (SCOs) defined in the organization. 
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
5
Organizing learning objects and SCOs 
An organization of items 
The organization of the SCORM learning objects in a package is described in a hierarchical 
tree structure, such as a course structure or hierarchy of content. SCORM does not specify a 
particular depth of the tree. Also, SCORM does not specify any particular nomenclature to 
name the levels of the tree, such as "course, lesson, topic" or "unit, module, lesson.” You are 
free to use whatever nomenclature you like, or none. The length of the branches of the trees 
may vary. 
Each item in the tree can point to a learning object, or it can contain other items. Each item 
must have a title, which a run time environment will display to the learner. 
An item in the tree can have children and also point to a learning object. For example, if your 
content hierarchy represents sections, chapters and pages, the chapter headings may have 
their own "cover page.” However, in SCORM 1.3, only learning objects associated with leaf 
nodes in the tree will be launched and tracked as SCOs.  
You can mix and match SCOs at all levels of technical compatibility within the same 
organization. For example, you can aggregate simple, one-page SCOs created with Notepad 
with complex SCOs created with an advanced authoring tool such as ToolBook. 
Similarity with other organization models 
Older organization models, like the AICC block/AU structure, can be mapped directly into this 
organization model. 
Content organization models that use directed graphs cannot be represented directly in the 
SCORM hierarchical tree structure. However, many directed graphs can be represented by 
making multiple items point to another organization in the package, instead of referencing a 
SCO. See the description of the packaging manifest (below) and the IMS Content Packaging 
specifications for more information on how to achieve this with sub-manifests. 
Sequencing 
SCORM 1.2 does not define how to sequence SCOs. User-choice sequencing is assumed.  
User-choice sequencing 
In user-choice sequencing, the runtime service allows the user to choose any item in the entire 
learning objects organization. Depending on the implementation, this could be accomplished 
through a visual tree, a menu or a set of nested menus. SCORM 1.2 does not specify what the 
user interface to choose an item will look like.  
For example, a typical implementation with a table of content may work like this: When the 
learner selects an item in the table of content, the item is highlighted and the corresponding 
learning object is launched in the stage window. If the item has children, but no learning object 
of its own, the first child that has a learning object is highlighted and that learning object is 
launched. 
Special rules for some items 
Mastery score 
You can assign a mastery score to an activity that uses a SCO. If a score is reported for the 
SCO, the runtime service compares the score with the mastery score to set the status of the 
activity to "passed" or "failed.” This overrides any status that may have been reported by the 
SCO.  
Timeout and timeout action 
See details in the SCORM specification. The runtime service can unload a SCO when the time 
allowed has expired; however this behavior is not well defined and may not be available on all 
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
6
implementations because it requires the run time environment to be more complex on the 
client side. 
Prerequisites 
SCORM 1.2 defines a very basic form of prerequisites. A prerequisite references another 
element in an organization tree that must be completed or mastered. However, because the 
SCORM specification does not clearly define the behavior associated with prerequisites, only a 
way to specify them, use prerequisites at your own risk. SCORM 1.3 will include more robust 
sequencing rules that will not rely on hard-wired references between items, but that will instead 
allow adaptive sequencing decisions based on the status of learning objectives. 
Implementing SCORM-compliant learning objects and SCOs 
The runtime service 
In order to implement SCORM-compliant learning objects and SCOs it is useful to understand 
a little bit of the runtime environment in which they will be used. To distinguish this runtime 
service from the rest of the LMS and its login, authentication, storage and reporting services, 
we will refer to the runtime environment and the processes that manage it as the "runtime 
service.” 
The distinction between LMS and runtime service can be useful because an LMS and the user 
experience may have, for example, different latency requirements.  
The runtime service can be implemented in part on the client side (i.e., on the learner's 
computer) and in part on the server side (i.e. somewhere on a server). In an offline situation, 
the server side of the environment is emulated by an application that runs on the learner's 
computer.  
The client side of the runtime service:  
‰ 
Is provided by the LMS;  
‰ 
Is implemented as a Web page or frameset in a browser window; 
‰ 
Presents some necessary runtime user interface components to the learner, such as a 
table of content and/or navigation buttons; 
‰ 
Launches learning objects in a "stage window" that is either part of the frameset, or a 
separate window that it creates as needed; 
‰ 
Includes an API object instance named "API" that can be found and called by JavaScript 
or ECMAScript; 
‰ 
Is generated or regenerated as needed by the server side.   
The server side of the runtime service and the rest of the learning management system are 
completely invisible to the scripts in SCORM learning objects. The user interface components 
of the runtime service, such as a table of content or navigation buttons, are also completely 
invisible to SCORM learning objects. How the client side of the runtime service is 
implemented, and how it communicates with the server are totally invisible to the content. The 
only parts of the runtime service with which a SCORM learning object can detect and 
communicate are: 
‰ 
The stage window 
‰ 
The API adapter 
‰ 
The functions provided by the API adapter 
The learning objects are specifically prohibited from navigating to other learning objects within 
the stage window. Only the runtime service can load another learning object in the stage 
window. The runtime service uses the content organization defined in the content package as 
its guide to manage navigation between learning objects. 
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
7
Chapter 2 - Basic SCO behavior 
Simplest SCO 
Basically, a SCO is some Web-based content that communicates with the runtime service 
after it has been launched and again when it finishes. 
In its simplest form, such a SCO would be a Web page with a short script. It can also consist of 
multiple HTML pages. The samples in the Appendix section of this document show how 
simple a single-page or multi-page SCO can be, especially when using "canned" generic 
scripts through inclusion. 
When the SCO is loaded, the script finds the API adapter, and calls the function 
LMSInitialize
of the adapter. 
When the SCO is unloaded, or at anytime before that if the SCO determines that it is finished, 
the script calls the function 
LMSFinish
of the API adapter. 
Get and Launch SCO
SCO
Parameters
Time
LMSInitialize
LMSFinish
LMS client side
run time service
components
Monitor SCO status
Manage data transfers
User interface for
inter-SCO navigation
Figure 2.1 – A simple SCO 
Behaviors and responsibilities of a simple SCO 
‰ 
When launched, find the API adapter by searching in a specific way. 
‰ 
Having found the API adapter, call 
LMSInitialize
to begin a communication session. 
‰ 
When finished, call 
LMSFinish
to terminate the communication session. 
COOKING UP A SCORM V.1.2 
COPYRIGHT © 2003  
Documents you may be interested
Documents you may be interested