Picture a company with offices scattered around a country the size of the entire continent of Europe, some of the offices deep within the world’s largest jungle, and others in cities that the company itself had to build in order to accommodate its mining workers. It would not be difficult to show that the cost of travel to centralized training locations for employees and instructors would be more expensive than deploying e-Learning infrastructure. That would be a dream for showcasing e-Learning strengths.
Now imagine that the company has
decided to implement a new
The number of different modules can be pretty large as it is. But an ERP implementation usually goes through test phases where last minute changes are the rule. If the training didn’t keep up with all those changes, instruction would only be a waste of time.
That really looks more like a nightmare, not a dream showcase, for the training project manager. And that’s precisely the scenario I had to deal with when the third largest mining company in the world called my company to take care of the development of their new ERP e-Learning initiative.
No matter how great a job we might do planning, organizing, and managing the project, one thing was clear from the very beginning: We had to come up with ways of developing things fast. This would allow the training development cycle to start later in the project — and the later we started, the more up-to-date the content would be. Not only that, we had to be prepared to change whatever was needed as the ERP system evolved, maybe days before the training start date, maybe hours, maybe even after it began. OK ... we needed more than fast. We needed lightning fast! Or immediate.
Speeding the process the right way
There’s no magic trick to building things fast. Better planning, a good team and keen management can speed things up a great deal. But if you need to really put your project in turbo mode, there is only one way to go: Working less. I know that smells like doing a worse job. That’s not what I intend to write about.
I’m talking about using components that worked great for an old project in a new one without having to redo them. And I’m also talking about really putting your computer to work for you. Maybe experience with some “do-it-all” systems and applications taught us to think twice about how a capable a computer really is, but being a certified geek I would like to encourage you to have faith again. Here’s my creed: There are easy and inexpensive ways to use all that CPU power you’ve been hearing about in the ads.
Computers are not intelligent, and they are certainly not creative. They weren’t created for that purpose. A computer is just a machine, and humans invented machines to do repetitive, identical tasks that require no problem-solving. We even started to call such tasks mechanical.
If you want to use a computer to do what it does best, you need to find compatible tasks within your project. Although your PC will never grow to be an intellectual or an artist, it can be a better factory worker than you could ever dream of being. Just ask some (former) auto-assembly line workers what happened after robots showed up everywhere in the plant. The good news here is that there are a lot of tasks in e-Learning design, development, and production that are intellectual and creative, so no one is facing unemployment when I say that a typical e-Learning project has many tasks that one might automate.
It is probably easiest to identify these tasks in the development phase. It is no wonder that most e-Learning authoring tools, and especially those devoted to rapid e-Learning, are designed to automate production of the multimedia training module.
Choosing what (and how) to automate
Methods for automating the process of converting content that an Instructional Designer formatted to a full multimedia module may not be obvious. There are several tasks and decisions the graphics designer must perform successfully to achieve that result. Just using a computer doesn’t guarantee an improvement. After all, the final product is computer software, so any means of development, no matter how old-fashioned or manual, will have to involve a computer.
Once again, the way to improve the job is to make the computer do things without human assistance. What courseware components can be built like this? The answer at first is “not many,” but in time it becomes “almost everything.” Sounds confusing? The factor driving that change is simply reusability.
There are many components that we need to build in every e-Learning application, and many of them are similar or identical across applications. If something we built works great, why build it again and again from scratch? That’s exactly what many of us are doing right now. Our development ideas are aimed at automating the process of reusing components.
Let us take a look at the typical components of a screen display as seen by the learner. (See Figure 1.) There is the User Interface (UI), with buttons that allow the student to control the navigation, and things like a title area and a course map or progress bar that allows the application to provide information about the student’s progress. Then there is the content which you can divide into two components:
- The content itself, in any medium, such as text, illustration, pictures, animations, simulations, audio or video; and
- A layout for this content, describing how it should be shown onscreen.
Figure 1 The screen components
Each screen can have as many content elements as the Instructional Designer (ID) sees fit, but the screen only has one layout. The ID normally decides on the layout during the design phase, in that famous document called the storyboard. There the designer can see how the ID organized each screen, and can build layouts accordingly. Using this process called our attention to one obvious fact: the layouts can be very similar or even identical among certain screens, making them excellent candidates for re-use.
In order to get something reused with other components you need two things:
- The content to be reused, which must exist independently from other components
- An application to gather such components automatically
In other words, the layout should be in a single file, completely separated from the content files. And to experience the full benefit of reusability, it is best to have the computer join content and layout making a neat screen. If the Graphics Designer (for example) simply opens a Flash layout file, and then copies and pastes each content element into placeholders in that file, it would be more like customizing than reusing. By reusing I mean that no editing is involved. You pull the correct file without ever opening it, and let the computer do whatever it needs to do.
The first step in our project was to separate the files. Our team developed almost everything in Flash, as it is extremely flexible, portable, and compatible across platforms, and helps to make the results look good. So the layouts should be in Flash files, commonly called templates.
What about the content? The media is originally in separate files, being jpg, gif, mp3, mov, swf, and so on. For the text we decided to use XML. It is easily readable by computers since XML libraries are available for every language, and also readable by humans for diagnosing any problems that might occur. XML also ensures portability and compatibility with other systems. After we made these choices, instead of a Flash file full of content for each screen, we had (see Figure 2):
- XML with the text
- Several media files in various formats
- A template file
Figure 2 Separating elements
We also added the screen information, such as the template it uses and the media filenames in the XML file with the text. For example, see Figure 3 for a typical screen XML file, for a screen with one textbox and one picture.
Figure 3 A screen XML file
We built a JavaScript/ActionScript application that would read this XML file, load the template on the screen, load the text in the textboxes in the template, and also load the media files in their boxes. All we needed to do was build the proper XML files and the application would show things neatly on the screen, with no noticeable difference between this method and the traditional single Flash file for the student. What was under the hood could be complicated, but we needed to make sure that this would not affect the learning experience in any way. Getting that right required two to three months with a dedicated staff.
Now your Information Technology (IT) people are probably comfortable with XML files, but IDs are usually not. Building XML files by hand would also be a step back from simply using the storyboard. We needed a good interface that would allow IDs to generate XML files — yes, you guessed it — automatically.
Building an interface is no trivial matter. Sometimes people treat it as only a simple addition to a piece of software, but this can lead to tragic development mistakes. First, the interface has to have a good, well-thought-out layout. Not only must it provide good interactions with all the software functionalities, but it also has to provide them in a visually organized and available fashion.
Second, the interface programming can be quite tricky. Once an application has been deployed, it is very common for the users to start having all kinds of brilliant ideas to enhance it. All of a sudden the interface becomes an application in itself, and failing to treat its development as such might introduce nasty bugs and limitations to future developments.
Third, when you build an interface for an application you start increasing your development efforts. If it needs a new functionality, you have to change the interface accordingly. Everything takes twice as long and requires twice the budget. What usually happens is that the development cycle for newer versions becomes longer than desired, and that may even lead to freezing improvements due to lack of resources.
One of the ways to avoid that and make a straightforward interface implementation is, again, to use something that is already available and works well. Deciding what to use is a matter of analyzing what type of functionality and interaction you need, and looking around to see if there is an application that would help. The XML files for each scene had the following data:
- One screen name — to serve as both a reference during debugging and the XML file name
- One template file name
- At least one component, being either:
- Written text
- Media file names
- For each component it might be useful to categorize its type
A good way of visualizing this data would be a table similar to Table 1.
| Screen name | Template | Component type |
Component content |
| Screen_1 | text_media | Textbox | Hi, my name is Jack! |
| Media | jack.jpg | ||
| Screen_2 | just_media | Media | interaction.swf |
| Etc... |
Building XML from such a table would consist of using a program that could simply read the table cells and then write the text to a file in XML format.
At this point we decided to use Microsoft Excel as the interface. Although Excel is for people who need to organize and operate with large matrices of numbers, it is also a superb tool for working with tables. Because it is already organized as a big table, it is much easier to fill the cells, navigate and format tables in Excel than in Word or in other text (or even XML) tools. Excel 2003 has native support for XML, where you can choose a set of fields that will synchronize with an XML file.
In case you’re not comfortable with that, or you need more flexibility and control, you can use Visual Basic — a well-known language — for the same purpose. Visual Basic (VB) by Microsoft fully integrates with any Microsoft application, so it is pretty simple to write functions that will read from cells and manipulate the data in an Excel file. You can save the application as part of the Excel spreadsheet, ensuring a simple operation. As a last advantage, anyone using Microsoft Word or Outlook will probably already have Excel installed, as it is also part of the MS Office suite. That was our case, so it made perfect sense to give it a try.
Building the spreadsheet was straightforward. Just insert the headings and let the instructional designers fill the rows. The toolbars in Excel are almost the same as in Word, so anyone used to Word will be able to come up with a nice table in Excel in no time. You may find it useful to know that
CTRL+1 brings up the formatting menu for the current cell or current selection.
Figure 4 is a sample of our spreadsheet model.
Figure 4 The spreadsheet
Our scene names followed a coding system for historical reasons. You may come up with any names you like. We also included Glossary and FAQ spreadsheets, which were simple tables listing terms/questions and definitions/answers. For the Glossary it is possible to take advantage of the fact that Excel can order all columns of a table alphabetically using:
- The Sort Ascending button, or
- The menu command Data | Sort
A formatting trick we used shows how powerful Excel can be if you are willing to dive into its features. We found it useful to differentiate screens by alternating row shadings as you can see in Figure 4. You can do this using conditional formatting, a functionality that allows a cell to change its font, border or shading depending on its content, or on any formula result. To do this, you must first select the cells you want to format (in our case the entire spreadsheet excluding the headers) and use the menu command Format | Conditional Formatting. A window similar to Figure 5 will appear.
Figure 5 Conditional formatting in Excel
Using the conditional formatting dialog box, you can insert criteria that will change cell formatting. To make color alternate for each new screen we applied the following logic: Every other screen will get a gray shade. We know that the screen changes when a new name appears in column B (refer to Figure 4). So our coloring criteria could be, “Count the number of screen names in column B until the row where the selected cell is located. If this number is even, color the selected cell.”
Suppose you have selected just one cell in row 6 and you apply this formatting to it. After opening the conditional formatting window you must change the “Cell Value Is” field to “Formula Is,” indicating that you’ll insert a formula to be evaluated. The function in Excel that counts filled cells is COUNTA. It accepts a range of cells using Excel range syntax, separating the first cell from the last one with a colon. So COUNTA(B4:B18) would give us the number of screen names (and thus screens) until row 18.
However, we want to use different ending row numbers depending on the cell we are formatting. Excel does that easily. Any formula, when copied from one cell to another, will transpose row and column values accordingly. For example if the formula COUNTA(B4:B18) is in cell B18, and we copy and paste it to cell C28 (one column to the right, 10 rows below), you will see that it changes to COUNTA(
C14:C28). This is the standard behavior for any formula. If this is not the result you want, just put a dollar sign “$” before the coordinate you don’t want changed. In our example, if our formula was COUNTA($B$4:B18) it would change to COUNTA($B$4:C28) after pasting to C28. Whatever comes after “$”, either column or row, doesn’t get transposed.
We also use the function EVEN to round any number to the nearest even number. All that explanation leads to a simple formula. To better illustrate let’s suppose you are formatting any cell in row 6. Figure 6 shows the formula you should enter.
Figure 6 The color-changing formula
This formula compares the number of screen names found in column B until B6 with the nearest even number. If they are the same, then the number is even, and the formula results in TRUE. If they are not the same, the formula returns FALSE. The dollar signs ensure that when you copy this formatting to other cells it will still count values in column B — notice every B has a dollar sign before it. The range will end in whatever row you copy the formula to, as there is no dollar sign before the ending row value (6 in this example). (Hint: you can use the Format Painter button to copy conditional formatting.)
This is probably easier to understand by trying it for yourself. I would advise everyone to learn more about Excel functions and how they work after copying and pasting. Because of all these formulas and conditional formats, Excel can be a powerful and flexible interface for your applications with no need for special macros.
