|
Tom L. Hall President |
|
Issue 6
March 26,
2007 |
Welcome to
this issue of my Newsletter. I have been
busy reviewing the various preview releases of Blackcomb and will make a report
on that as soon as I can. This new
release shows a lot of promise but as with all releases, there are many issues
to be worked out, but I have faith that will happen this time as it has in the
past. I likely will get the award for
most bugs found this time as in the past, but that's mainly because I really
put each release through the paces with all the lessons in my books and project
files I have worked on. A new feature, SmartStyles,
is an exciting feature that I am spending a lot of time trying to get to
understand. I will report on this also
when I can. Something else I will report on is the issues related to version updating
as they pertain to old code from objects in earlier versions of ToolBook.
In this
issue, I will discuss the ToolBook Rapid
Development Suite, a product developed jointly with Lee Karns. A later
issue will discuss the Comment Collector as a standalone product.
In this Issue:
The Starter and Template Books
The ToolBook Rapid Development Suite (RDS) is a collection of services,
utilities, and ToolBook applications that integrate into a process of Web Based
Training program development. Our goal is to work with you to put a process in
place that enables you to more effectively create the training you need in the
most efficient manner possible.
The financial
success or failure of the development of training applications has much to do
with managing the process so that the entire initiative meets budgetary
expectations. The RDS was designed to streamline communication between Subject
Matter Experts and programmers, and to create a programming system that
capitalizes on the immense power of ToolBook's template capabilities.
The RDS
includes:
- A Storyboard Builder for
Content Lessons, Assessments, Simulations, or any combination.
- Starter (Blank) book to be
used to build the lessons.
- A System Book that contains
the coding to do most of the Authoring (the Authoring Engine).
- A book of Template Pages to be
used by the Authoring tool to build the lessons.
- A Comment Collector system
(via ASP, JavaScript, and Database) to allow quick review of the lessons
along with the ability to track basic types of information such as number
of times a lesson has been accessed and scores for assessments as well as
turn on or off "hidden" functionalities.
Note: The Comment Collector System can
also be used as a standalone product if you do not want to use the Rapid
Development Suite. A simple setup of your starter book or books and the
Database setup with the ASP pages will allow this to happen.
The Storyboard Builder (an application built entirely in ToolBook)
is used to write Storyboards for any of the following types of lessons:
- Content
Only
- Quiz
(Assessment) Only
- Simulation
Only
- Any
combination of the above
At the
core of the Storyboard Builder is a Menu Bar that provides options for
inserting into a Storyboard the various types of pages of pages.
Here, you
see the types of pages that are categorized as Content screens. To use this,
the Storyboard writer has only to go to the page after which a new page is
needed, and then choose the desired page type.
Below, you
can see the various types of Quiz
screens that can be added to a Storyboard.
Finally,
the graphic below shows the types of Simulation
screens that can be inserted into a Storyboard.
The various Sim (Simulation) Scenarios will be described later on.
An option
from the Menu Bar as well as an icon on each screen provides access to a Screen List where the writer can
quickly see an outline of the Storyboard as well as quickly navigate to any
page. Notice a Print List button is also available.
The Maintenance Menu provides vital options
as the writer creates the Storyboard.
For instance, clicking Store Data
produces an ini file that is then used to build the final book. Notice from here that you can copy, paste,
and delete screens.
The Format Text menu provides options for
formatting text within the Storyboard in such a way that formatting is applied
in the built book.
The Find/Replace option uses ToolBook’s
built in ability to do a find and replace of text.
The Help option gives popup help such as a
listing of the various Simulation Scenario types that are available as shown
below.
The goal for
the Simulation Screen types is to
keep each screen (page) as simple as possible and we have attempted to identify
as many types of interactions as possible.
As you can see from the above graphic, we have identified several
situations where it is best to have multiple steps on a single page.
Below, you
see several Non-Simulation Screen
types that are used primarily to go along with Simulation lessons.
Below, you
can see the various Content Screen
types we have identified.
Finally,
shown below are the various Quiz Screen
types.
As shown
below, for each screen that is inserted, sample text is provided to aid the
writer as they write the Storyboard.
Writing the text for a page (screen) is as simple as filling out a form
once the writer has inserted a desired page (screen). We have established a uniform naming system
for the book, the page, and any graphics as you can see from the graphic
below. The pre-approved text provides
for consistency between lessons and this is especially important if you have
several writers.
Note: It
will be likely that you will want some customization here to account for text
conventions you will want to use. This
will occur in the Storyboard Starter book provided since this is the book that
is saved each time a new lesson is to be built.
As
mentioned earlier, a Store Data
option takes the information from the Storyboard and stores it in an ini
file that then is used by the Authoring Engine to built the final book. Below,
you can see the section of the ini file that is created as result
of the above page. Notice the special
formatting “tags” that have been added since no formatting can exist within the
ini
file itself.
|
[100_300_105] PageName=100_300_105 SimType=Sim
A PageNumber=3 ScreenShot=100_300_105.gif UA1=Click
Catalog icon on Tool Bar. SR1=The
Catalog opens. DMT1=One
way to open the Catalog is to use the Tool Bar. To do this, you would click
the <b>Catalog</b> icon on the Tool Bar.||Click Try Again or
click Continue. PMT1=Click
the <b>Catalog</b> icon on the Tool Bar to open the Catalog.| FBT1=That
is incorrect. The correct response is to click the [Catalog] icon on the Tool
Bar.||Click the Continue button. SN1=[F2]
also can be used. |
A BookInfo section holds vital
information related to the lesson such as the name of the book, the project
code, the Lesson Title, the Storyboard writer, as well as version information.
|
[BookInfo] PageList=100_300_300,100_300_190,100_300_105,100_300_090 RDS_BookName=100_300 ProjectCode=RDS_100 ProjectID=1 LessonTitle=Basics
of ToolBook Simulation SBAuthor=Tom VersionNumber=1167308607 DateLastSaved=12/28/2006 TimeLastSave=12:23:29
PM |
Note: If you determine that in your project
you will need different page types than those we have defined, then there will
be a need for some customization of not only the Storyboard Builder, but likely
also the Authoring Engine and the Template Pages book. Many of the existing page types can likely be
easily customized to make minor changes but due to the large amount of coding
involved on both sides (writing and building), then consider this is where you
will likely spend the most amount of money on us to get a project up and
running for you.
The
Storyboard Builder also has a version control system built in so that the
writer can record and track changes that are made to the Storyboard.
Another
part of the Storyboarding process is the gathering of graphics and
screencaptures (if a Simulation page).
For Simulations, we will often use Camtasia
and shoot a video of a series of steps, save it as an exe file, then upon
playback, use Snagit to grab the
individual screens we need.
The Starter and Template Books
To be able to build a final tbk
(lesson), it is necessary to have two files:
- The Starter
Book (often named blank.tbk)
- The Template
Pages Book (named rdspages.tbk)
The Starter Book
For each project, it will likely be necessary to swap out the existing graphics
to get the design you wish. Below, you
see the basic design with a background image, a title text image, and the
navigation buttons.
A menu option from the Authoring menu makes it easy to export the
existing graphics so you can make modifications and then import the new
graphics back into the book. The same is true with the Template Pages. It will be recommended that you stick with
the current sizes of the button graphics or once again a good bit of time will
need to be spent doing a customization.
The same is true with the layout of things like the navigation
buttons. A reasonable ToolBook
Programmer can do all of this, but with the amount of code that exists throughout
the fileset, it will be very easy to break something along the way.
This Starter book has code to allow the built book to work as desired.
This includes a link to a JavaScript file and functions that provide the
ability to turn on and off a Comment Collector system and then to use the
Comment Collector system.
The Template Pages Book
This book contains all the various pages that correspond to the page
types available in the Storyboard Builder.
The main thing is that all interactivity is pre-programmed and tested in
advance of the start of the process of building the lesson books. In the case of a Sim A Scenario as shown
below, the Simulation is already set up to run in Practice Mode with a
Demonstration Mode (Show Me) optional on each screen. The Learner is given 3 attempts and generic
feedback is given for the first two, while very specific feedback is given in a
Feedback Text Pane (with pointer) for the final attempt. On a page such as this, the graphics
placeholder for the screenshot is already available, as it the hotspot for a
correct click, along with highlighters, the controls (including Continue
button), the instructional text field, and the feedback field.
After this type of page is built, all that is needed is to properly size
and position the hotspot (the transparent yellow rectangle), the highlighters
(which include both red and green rectangles), and the Feedback Text pane. It is estimated that this is about a 30
second job as opposed to likely having to spend 30 minutes or more to build
this type of page from scratch. Even if
the template page exists, without the use of the Authoring Engine component of
the RDS, you would have to likely spend 5-10 minutes making the necessary edits
to the Simulation Editor (such as inputting the correct text and feedback,
etc.).
The Authoring Engine
is a system book that we link to from the Starter book. This book contains all the code needed to
create or edit a final tbk (lesson) from the Storyboard ini
file.
When this system book is loaded, an RDS Author menu appears and provides access to the Create – Edit Lesson From Storyboard
routine as well as a host of utility routines as shown below.
When the Storyboard Builder is launched within any blank
that has been saved as a new lesson or when launched within any built book, the
Developer has the options shown below:
- Create - Edit Complete -- allows for a complete build of the
lesson and most often is used to build a new book
- Update Graphics Only -- allows only the graphics to be
updated such as a case where the application screens have changed
dramatically
- Update Text Only -- allows only the text to be updated
such as a case where minor text edits have been recommended during the
various QA cycles
The process of building a book is very fast and only takes
2 minutes or less for a 40 page book.
Once built, it’s just a matter of quickly positioning objects as
described earlier since the programming has been taken care of in the Template
Pages.
Below is the finished page that we showed you the
Storyboard text and template page for earlier.
At Reader level, we don’t see the hotspot but it’s the small rectangle
that we showed earlier that has been positioned on top of the Catalog icon part
of the screenshot. The Feedback Pane has
been moved and resized and the pointer directed at the hotspot while the red
rectangle has been moved and resized to show where to click if there has been
three bad attempts.
It all boils down to this: It most often takes more time to publish the tbk file to HTML than it
does to build it, especially when updating the file since in that case the
positions and sizes of objects have already been set unless a screenshot change
in something like a Simulation changes.
An option from the RDS
Menu allows the Developer to track changes made to the built book.
Finally, a Change
Control Log can be accessed from a “hidden” button on Page 1. This log
shows a history of changes to both the Storyboard and the built book.
During the Review process, the visibility of a Comment Collector button is controlled
by a function in a JavaScript file:
|
function tbfunction_RDSStatus() { //Get the value
for the CIS_Status Variable //first char: 1 = review
comment collector shows up, 0 = hide the widget //second char: 1 =
enable mode selection group, 0 = hide the group //third char: 1 =
show score troubleshooting group, 0 = don't show it //fourth char: 1 =
show the Review Completed button on last page of the wbt //fifth char: 1 =
turn on the usage tracker object //sixth char: 1 =
show the student question group //seventh char: 1
= turn on HTTP Post actions, 0=turn off HTTP Post actions //Note: If
Switches 1,4, and 5 are on, then Switch 7 needs to be on. var RDS_Status="1000000000" return
RDS_Status; } |
When the first character of the Status string is 1, we show
the button. Thus, with one simple edit to the JavaScript file for the entire
project, we can turn off and on this feature, even after final deployment of
the product.
When this button is clicked, the Reviewer gets a form to
fill out. The Reviewer is prompted for their name before the popup below shows.
Behind the scenes, the name of the book, the page, and Simulation mode (if a
Simulation page) are the various bits of information gathered.
Once the Submit
button is clicked, the information is submitted via a JavaScript function and
ASP pages to an SQL database. Below is a
sample menu of comments from the Database.
As the Developer, I would click this link to look at the
comments that have been made during any QA cycle.
Now, I would click the Edit
link (above), add my comments, and normally mark the comment as Fixed (below) if I was able to fix the
problem. In this case, the comment will
no longer show up on the menu.
Notice in this case all the information gathered by the
Comment Collector system such as the Page Name, Page Number, etc..
Click here to see samples of several different types of lessons
built with the RDS and a live look at the Comment Collector System.
TCC Publishing, Inc
Internet Address: tomhall1@tcc-pub.com
Phone:
252-758-4590
Fax:
252-758-4590