The Advanced Distributed Learning (ADL) Initiative is proud to announce that all non-sensitive development projects will be hosted publicly on GitHub! We believe that the open development model provided by the site aligns well with the prototypical nature of our upcoming projects, as well as principles outlined by the Open Government Initiative. This post will brief you on where we’ve been, where we are now, and what’s to come in the rapidly-evolving ecosystem of ADL software.

The Stone Age of Collaboration

Our goal is to enable developers across the world to leverage the in-house research prototypes we create for building powerful technologies that push the state of distributed learning forward. In the past, however, fractured developer communities and restricted-access version control systems made it difficult for anyone outside of our organization to improve or collaborate on any of the software we put out, including SCORM-related tools. With the exception of the Test Suite, we put the software out there with plenty of documentation, source code, examples, etc., but once it was there, there was no way for the community to fix it or make it better.

As a developer not working for ADL, to improve our SCORM software you would have to scour the ADL website for the right person’s phone number or the help desk, then use closed communications channels to possibly get the engineers to update the software, which then would require a formal release and all the announcement fanfare that comes with it. That’s a lot of flaming hoops to jump through. At the end of it all, no public record even existed documenting what had gone on, and releases were slow. A lot more effort and synchronous communication was made than should have — from both sides. That was the “Stone Age of Collaboration” because our development model wasn’t open. Then we discovered GitHub.

The Spark

GitHub fixes many of the problems that previously hindered the open flow of information between ADL developers and the people who use the software we developed. For those unfamiliar with GitHub, it is a an enhanced web-based hosting service for projects using the Git version control system. The site is already extremely popular with the open source community, with millions of users, contributions from big-name tech companies like Facebook and Twitter, and countless projects that, out of the kindness of devs’ hearts, are shared with the public, usually with very permissive licenses.

If we want to find people who are interested in SCORM development, the chances are exponentially higher that they will find our projects on the site and use a version control process already familiar to them (Git) to start hacking away. For each project, GitHub also provides an easy-to-use issue tracker and wiki that lowers the barrier of entry for reporting bugs/feature requests, or learning more about how a piece of software works. Our developers are notified immediately via email if an issue is reported, and can respond to it in a more direct and asynchronous fashion that meshes with their daily workflow.

And if you like our software, but want your own version, or want to put your own feature into it, you can “fork” the project into your own personal account and make that awesome learning app you’ve always wanted to. No more asking for Subversion usernames and passwords, no more going to the “Help Desk” to find who can help you. And no more wondering whether the next official update to SCORM 2004 4th Edition Test Suite will clash with what you are developing, because now all updates can be seamlessly integrated into a project that references it or on your own fork. So. Much. Simpler. Like. One-word. Sentences. (Okay, so there was a compound in there, you caught me!)

Transparency in our workflow is another great thing that GitHub enables. I’d be willing to bet that many a taxpayer has wondered what all these government folks and contractors are doing in their offices all day. Well, now we can show you not only the deliverable, but how we got there, who’s working on what, and how often. This data incentivizes developers to be very active on our projects by frequently committing new updates and interacting with the community. We also hope that this encourages developers to be more careful when designing, writing, and testing software, because their professional reputation is on the line and can be positively or negatively affected.

The Fire to Come

We already have several of our more recent projects out on our GitHub account:

• 3D Repository (3DR) – a repository for storing, converting, and sharing 3D content
• LR.Net – a .Net-based client library for the Learning Registry project
• LR Publisher – a GUI tool for publishing documents to the Learning Registry
• LR Data – a utility for pulling data out of Learning Registry nodes into more familiar and easily searchable datastores.

Plenty more will follow in the coming months as we begin to work on the next generation of SCORM and consider opening up some of the existing SCORM software for the community (speaking of which, weigh in on this topic here). We strive to serve as an example of how software development in an open government should be done, and hope that others may follow suit so that we can approach the singularity faster than ever…or maybe just make the world a better place, one line of code at a time.

Fork away, my friends.

The ADL Initiative is interested in creating open source versions of SCORM-related software. In 2011, ADL renewed its focus on research and development projects. This includes two major research areas: Next Generation Learner and Next Generation Learning Environment. The Next Generation SCORM project is now a main focus of the ADL Technical Team.

SCORM has been a major success for ADL. As a result, we will continue to support our stakeholders who have invested in SCORM as we move forward on the Next Generation SCORM project. However, support to update SCORM-related software will be restricted. In addition, several highly adopted versions of SCORM have not been maintained for years. For example, the SCORM Version 1.2 Conformance Test Suite Version 1.2.7 has not been updated for almost a decade, but SCORM Version 1.2 is still widely adopted by the e-learning community.

To respond to the needs of the community, ADL is considering the release of certain software products to our GitHub open source development portal. Although most of the code has been released as part of our software downloads, there has not been a concerted effort to manage updates by the community and roll them into the current release. The following list details the potential open source software releases:

SCORM 2004 4th Edition

• ADL SCORM 2004 API Wrapper JavaScript File
• SCORM 2004 4th Edition Test Suite Version 1.1.1
• SCORM 2004 4th Edition Sample Run-Time Environment
• RELOAD Content Packaging Tool

SCORM 2004 3rd Edition

• SCORM 2004 3rd Edition Test Suite Version 1.0.2
• SCORM 2004 3rd Edition Sample Run-Time Environment Version 1.2.2

SCORM Version 1.2

• ADL SCORM Version 1.2 API Wrapper JavaScript File
• SCORM Version 1.2 Conformance Test Suite Version 1.2.7
• SCORM Version 1.2 Sample Run-Time Environment Version 1.2.2
• SCORM Version 1.2 to SCORM 2004 API Converter

Additional software or content examples may be added to the list if warranted by community interest.

In order to maintain a stable baseline and a clear project scope, the ADL Technical Team will assist with the creation of projects that can be developed by a small number of developers. ADL will assist with testing and merging of branched features into the main software release. Examples of potential projects include:

• SCORM Version 1.2 Conformance Test Suite – Fix Java-related bugs so that the Test Suite can be built and run on the latest Java Run-Time Environment (JRE)
• SCORM (all versions) Test Suite – Add configuration for required data model use. For example, Sharable Content Objects (SCO) must indicate whether or not they are ‘completed’ by setting cmi.completion_status
• SCORM (all versions) Test Suite – Update to add support for multiple concurrent users which will allow a single web-hosted solution instead of a software download for each user

The projects listed above were derived from frequent ADL Help Desk tickets. This is not intended to be a prioritized or complete list. Please indicate your interest in contributing to the proposed projects by responding to the three poll questions below.

Implications for Group Learning with Intelligent Tutoring Systems

In the 1980s I taught in an education project called Project SEED which teaches algebra and calculus to elementary school students who are classified as both belonging to a minority and within a poverty-level demographic. If this sounds interesting on its own merit, consider that the project employed a learning paradigm called the Discovery Method, an approach I would classify as “Socratic Learning.”

The fundamental principle of this method is that students are guided (through carefully-crafted teacher questions) to “invent” the target content themselves. The teacher does not use lecture or materials to didactically convey the subject matter. Advantages of using this method are:

• Inspiring a deep understanding and thorough retention of subject matter through the experience of “inventing” it
• Intrinsically incorporating an active and engaging learning process
• Fostering self-confidence in the learners’ capacity to learn, as well as in their general intellectual abilities (especially when they “invent” subject matter that is beyond their grade level, as in the case of Project SEED).

This approach is not well suited for factually-oriented subject matter, such as history and foreign languages. In such cases, a mix of rote learning techniques (for the factual material that requires memorization) and Socratic (for the material that can be deduced, reasoned, and inferred through thought process alone) might be used.

The following describes a typical scenario of a Project SEED class taught using Socratic Learning:

1. The teacher asks a question and calls on a student with hand raised, who responds with their answer.
2. The teacher asks the rest of the class to use hand signals (for example, thumbs-up or thumbs-down) to show whether they agree or disagree with the student’s answer and/or reasoning.
3. The teacher asks the original responder to choose students who are showing disagreement, to explain why they disagree. The process continues until all different ideas in the class are aired. During this process, the teacher NEVER shows any indication of whether an idea is “right” or “wrong.” All answers/opinions have equal weight and are accepted by the teacher/facilitator.
4. The teacher facilitates a discussion in which he or she draws students into testing the quality of the reasoning of each idea, asking questions that reduce them to their simplest logical components, expose their underlying assumptions, assess their internal consistency and consistency with previously established knowledge, apply them to example cases, etc. As in the previous step, the teacher is careful to not promote an atmosphere of “right” or “wrong;” instead, encourages a lively debate.
5. Through skillful facilitation and questioning by the teacher, the class inevitably reaches a consensus on one idea (signaling such with an “I agree” hand signal) due to its compelling logic and intellectual integrity (i.e., the “correct answer”).
6. The teacher shows students a textbook treatment on the subject that they have invented, validating/ checkpointing their invention and bolstering their confidence in their intellectual abilities.
   This scenario example applies to children in a K-12 educational setting. However, the principles and some of the techniques can be applied to adults in an educational or corporate training setting as well.

In terms of rendering this approach through technology, an Intelligent Tutoring System (ITS) such as AutoTutor® already models many elements of Socratic Learning and effectively reproduces the dynamic questioning skills of a Socratic teacher. However, current ITSs are designed only for one-on-one tutoring.

ITSs could be designed for synchronous group learning as well. There are significant advantages for students to learn Socratic style in groups; perhaps most important is that students can get and give feedback to peers, drawing on the greater pool of intelligence and knowledge afforded by a group versus a single student to “invent” the material.

Here is a scenario for how an ITS could operate to support synchronous group learning.

1. Students log in to the ITS at the prescribed time. They are not necessarily co-located (the ITS is a web application)
2. The ITS announces “what we are going to explore/ investigate today” (i.e., in traditional education-speak, the learning objectives), reminds students of the principles of good participation in Socratic learning (participation is key, there are no wrong answers, etc.), and displays information about who is logged on in this session (through displaying either pictures, avatars, or videos) to personalize the students to each other and promote a sense of teamwork.
3. The ITS displays each student’s “participation points”, which they have earned in past sessions by giving answers, explaining their disagreement with an answer, etc. These points are strictly based on amount of participation, NOT the content or quality of their ideas, or how popular their ideas were with other students. A gauge shows how close they are to the next milestone/reward level (similar to an online game).
4. The ITS starts with an open-ended question (e.g., “Now that you know how exponents work from the last session, what do you think a number to the zero power equals?”)
5. Student operate their ITS terminal controls to indicate that they have an answer.
6. The ITS randomly selects a student and asks that person to say their answer (privately communicated to the ITS). The ITSs voice recognition module processes it, stores it, and says it back to all students in its synthetic voice, with no attribution. This anonymity is necessary in most situations, where a few bright students would end up dominating the dialogue – other students tend to get lazy and not participate when they know that the source of the answer is someone who seems to be able to progress the group’s understanding much quicker than others, and therefore “probably has the answer that we will all end up agreeing on”. A system setting on the ITS can override this anonymity of the sources of answers and comments (for some groups it is helpful to identify sources).
7. The ITS asks (all using synthetic voice – very little of this scenario involves text on screen – and avatar appearance that is particularized for each student according to their demographic characteristics) students to indicate agreement or disagreement with the answer.
8. The responses are compiled and anonymously broadcast. It proceeds at this point sort of like an “idea auction”. “Disagreers” make “bids” by explaining their disagreement/answer, and others hear these explanations and vote among the original answer and the alternative answers. If the group is large, the answers are paraphrased by the ITS and students get to select from a list that appears on the screen to hear the full comment for any of the paraphrased answers. Students can request more explanation from a particular student (anonymous) who has given an answer or registered disagreement. The ITS states it back to the student.
9. Once a quorum of students has participated through voting on which answer sounds best to them (the original or some other answer with its associated reasoning), the ITS crunches the data and uses its Artificial Intelligence (AI) module to determine the next question to progress the group in higher and higher levels of rigorous investigation of the possibilities.
10. Students can indicate at any time what they believe their final answer to the original question is (all answers are qualified by students on their terminal as “final” or “temporary”). When a quorum of these is reached (close to 100% asserting the same final answer), the ITS announces that there is a consensus and explains what it is. If the consensus coalesces around the “wrong” answer, the ITS continues to ask questions.
11. The ITS congratulates everyone and compares their contributions with a Wikipedia or other scholarly entry on the subject, which situates their answer.

This manner of teaching and learning describes one approach to recognizing that learners of all ages are not showing up as “blank slates,” but instead bring all manner of previous knowledge and intelligence to bear on their own and others’ learning and are not seen as passive “knowledge receptacles.” Leveraging these notions to effectively meet educational and training objectives on a large scale is an important challenge for next generation education/training technology.

Open Source Status

I am happy to announce a major milestone for the 3D Repository (3DR) project: The ADL 3DR is now completely open source. This means that the community of users and other interested parties are completely free to review the technology and to modify, remix, and improve it. We hope that this step will lead to broader adoption and deeper collaboration between those interested in sharing and reusing digital content. The project is hosted by GitHub, the largest online code hosting service in the world. You can download the source code at: https://github.com/adlnet/3D-Repository.
You can also file bug reports, read documentation, communicate with the developers, and get copies of the installer files.

New Feature for 3DR Installer

A major step in the 3DR development is the first version of the 3DR installer that can update an existing installation without losing previously uploaded content. This important feature is necessary to allow partners to keep up to date with new developments. In the future, you’ll always be able to download an executable that will upgrade your installation to the most recent version.

New 3DR Instance

The U.S. Army Research Laboratory’s Simulation and Training Technology Center (ARL STTC) has installed a private 3DR instance, with plans to create a public-facing instance sometime in the future.

Development Report: Stage3D Viewer, Configuration Tools

We have two major development efforts running simultaneously. First, we’ll drop support for the Google O3D plugin. This feature has been with us since the very beginning, but the technology behind it has been overcome by events in the web programming world, and is no longer a suitable choice for delivering 3D content to browsers. Removing this feature will streamline the technical architecture under the hood, as we previously relied on deprecated tools no longer supported by Google. We’ll continue improving the WebGL viewer, and replace O3D with a viewer based on Flash’s Stage3D. Importantly, this viewer will parse the same JSON representation that WebGL does, further simplifying the server side code. Expect the Stage3D viewer in the next few weeks. The basic work is complete and simply requires integration.

Second, we’re continuing work to make setting up and maintaining a copy of the 3DR software easier. The majority of the settings that previously required an administrator to edit config files manually will now be accessible through a web interface. Should configuration errors arise, the system will be smarter about aiding the admin in fixing them – even going so far as to detect database connection errors, and will fall back to a recovery state that allows configuration changes even when the database is offline. Here’s a sneak peak at the configuration tools.

We hope these new features will continue to make the 3DR valuable to the training community. Please consider becoming a contributor to the project by downloading the source and improving it. As always, please let us know how we can serve you better.

After a long anticipated wait, the virtual platforms of Second Life and Open Simulator (OpenSim) now support the much needed function of third-party mesh importation. This has opened the door for new ways of creating virtual environments that do not rely on pesky primitive (prims) limitations only. For many years, artists and developers alike have desired ways to reuse mesh assets created in 3D modeling software for other projects and repurpose them in Second Life or OpenSim. Previously, the restriction of only using the built-in primitive toolsets have left many unimpressed with the level of fidelity that can be achieved with these two platforms. But fear not! The game has changed and now resources available on the web for free or in your own 3D library can be used with ease. Well, for the most part these models saved in the standard Collaborative Design Activity (COLLADA) file format will allow you to get models into the virtual space but what they look like in the end often times is not the desired look we originally intended.

The ADL 3D Repository has a large amount of assets in the .dae COLLADA file format. Great lengths were taken to insure that models uploaded from various sources would be parsed and converted properly in many formats. While technically the models are correct for importation, the way they look is often compromised. The computer has no way of understanding what is visually pretty and what looks completely wrong to the viewer. This is based on the way the model was created from the beginning. The artist may include features and building principles that Second Life and OpenSim do not recognize.
In the remainder of this article, we will cover some of the simple rules to fix these problems. We assume that the reader has basic knowledge of 3D modeling with the software referenced.

Sources of 3D Models and Tools

One of the great benefits to the ADL 3D Repository (Figure 1) is that a wide variety of subject matter exists that can help to rapidly build up a virtual environment; however, this is not the only resource. Purchased models from warehouses like Turbosquid, Square Pyramid and 3D Exchange are perfectly acceptable as long as they are in the COLLADA format. In order to correct the model, a third-party 3D modeling program is used to check for problems. Commercial packages such as 3D Studio Max, Maya, and Softimage all offer the ability to modify and correct the mesh and the textures associated with it.

If the commercial products are out of your price range, there are several excellent 3D tools available for free that work very well in this process. Autodesk offers a version of Softimage XSI (Figure 2) that has all the function of the commercial version for modeling. It can be downloaded from http://usa.autodesk.com. Blender.org offers an excellent open source 3D software package that is popular with the Second Life community. For the purposes of this article, Softimage XSI Mod Tool will be used; however, the principles are the same for other 3D packages.

Before we can start, the proper version of the Second Life client or OpenSim must be installed. If you are on the Second Life public grid, the current viewer 3 is available from Second Life. Several third-party clients have the mesh importation function as well. The Firestorm viewer 2 and the Phoenix viewer 1.6.0 are widely used. They can be downloaded at http://www.phoenixviewer.com/. If OpenSim is the preferred platform, the Diva distribution 0.7.2 is the best version of Open Simulator that supports mesh. It can be found at http://opensimulator.org.

Correcting and Optimizing the Model

The first step in the process is to download and unzip the COLLADA model of choice and import it into the 3D application. In the Mod Tool, you import the COLLADA file from the Crosswalk panel. Other programs may vary in this procedure. Once the model is loaded we need to check and make sure that the textures associated with it are there. The textures should appear if they were not moved from their original directory in the file folder. If they are missing, the textures need to be reapplied.

This model looks like it was set up properly. The textures are in the right place and the geometry has all the polygons facing the right way (Figure 3). Models that were made for other game engine environments typically have good polygonal reduction and an optimized UV texture setup. Second Life and OpenSim cannot see two-sided polygons. This can be a noticeable problem if the model has open surfaces or holes that show through to the inside of the mesh. These surfaces will render as invisible sides or seams.

Closing Open Edges

Unless the goal is to model the inside of an object with sides the camera can see, the best solution is to close any open edges and fill in the holes on the surfaces. Figure 4 shows the open edges as blue lines on the polygons. The red line indicates a selected edge welded into one contiguous surface.

In the Mod Tool, welding edges is performed by selecting two open edges and locating the dropdown command from the panel under Modify/Poly.Mesh/Weld Boundary Point/Edges. This can be a very tedious process but necessary in order to keep unsightly gaps from showing. Even edges that seem to be at the exact coordinates often times becomes offset inside Second Life. One contiguous mesh will provide the best result.

]]> http://www.adlnet.gov/from-adl-team-memberjeff-mills-helpful-practices-for-importing-3d-meshes-into-second-life-and-opensim/feed 0