How To Manage Version Control In eLearning Development
REDPIXEL.PL/Shutterstock.com

Ways To Manage Version Control In eLearning Development

Business owners, course designers, students, employees, and developers all agree on one thing:

eLearning is its own unique animal.

It requires a structure that many of those involved – from the teams creating and developing them to the users accessing and benefitting from them – have heretofore been unexposed to.

Of course, that's the operative principle at stake – 'benefit'.

A benefit can be measured in multiple ways:

  • As increased employee engagement and productivity at work, with increased end-client or customer satisfaction directly resulting from employee training and skills upgrades
  • A leaner workforce for a business moving into the era of AI automation
  • A more cost-effective way to offer value to a customer's experience of the business

But eLearning also raises all sorts of questions because it's the confluence of digital and programmatic development, educational and learning principles, and core user design.

One of the big issues is that of 'version control'. Questions surrounding this issue are usually things like, 'How much information do we want to give clients?', 'What is essential and non-essential information?', or, 'How can we ensure that everyone is spending time learning what is relevant to them without getting bogged down, without missing out and achieving consistent outcomes?'.

To understand the role of version control as a solution to these questions – separating learning elements between 'core' training and 'supplementary' training, and allowing students/users to select and forge their own learning path – we first have to understand the nature of eLearning and the potentially positive role of version control.

The key here is consistency in a user's experience and access to learning material, but not at the expense of cutting out important or relevant information.

The Network Model Of Learning

The original MOOC developers, Dave Cormier and Bryan Alexander, saw eLearning as an opportunity to connect learning. Their whole idea of online courses surrounded the principles of peer-to-peer sharing, collaboration, and choice in the path of learning, reflected in things like:

  • Course content available through RSS feeds
  • 'Dripped' or guided emails for piece-by-piece learning
  • Threaded discussions in an LMS platform like Moodle
  • Synchronous online meetings where students – not course instructors – direct the learning, conforming with the overall module's priorities

This 'networked' or 'nodal' model of learning relied on students as 'nodes' of connection, as well as 'courses' as 'nodes' of information. Their act of connecting is what formed that network. In truth, this vision of digital learning reveals itself to be perfect for version control.

Why?

Because when Cormier describes the principles of connectivism that undergird the digital learning experience, this is what he says:

"Two of the defining characteristics of connectivism are that the learning occurs through construction, annotation, and maintenance of learning artifacts. [emphasis added] A key characteristic of these artifacts is they must be persistent and be open, such that they contribute to knowledge, beyond the temporal or geographical boundaries of the learning group or course..."

If you've ever played around on GitHub, you'll understand that VC software works precisely on this first principle. Through iterations and tangents, literal 'changes' in the version are mapped to a new 'branch' of the version of information, code, database, etc., in order to annotate, experiment with, make changes to, and then maintain 'learning artifacts'.

Access to these files is 'open.' They contribute to shared knowledge and learning beyond any temporal or geographical boundaries.

This 'tree'-like structure that exists in the digital realm provides a neat, networked map that users can move forward on, based on the functions they are trying to achieve, incorporate or, in the case of digital courses, the material they want to learn.

What Is Version Control?

In its original, development-centric application, 'version control' is the ability to store files within a 'repository', tracking each version that is written to the repository and building an archive that stores these files along with metadata.

In version control software, there can be a 'local' or 'working set' copy, which is stored in a local directory where the user can make changes.

There is also the 'trunk' or 'main.' This is the primary location of the code within the repository. From here, all changes are tracked as 'branches'.

What do VC software and applications allow you to do?

  • Backup and restore to previous versions of files
    As these are stored in their own 'branch' the moment they are committed to or 'written' to the repository; jump to any moment in a past version.
  • Synchronization
    It allows all users to share files and stay updated with the latest versions.
  • Short-term undo and experimentation
    Access a module or learning resource, edit it, experiment, and then throw away your changes, reverting back to the 'last known good' version in the repository's database.
  • Tracking changes
    As files are changed, and a new iterative version or branch appears, version control software allows users to 'track changes' by leaving messages that explain why this file has changed and how.
  • Tracking ownership
    Remember that metadata information that VC software stores? Here's where it comes in handy. Tracking ownership in a peer-to-peer or open-source development environment is important because it's helpful to connect with the original author of the change or to give credit when moving forward.

Again, these principles come from software development. But when applied to the context of eLearning, version control produces some definitely positive results that amplify connected or networked learning.

What Does It Look Like for Digital Courses?

Within digital courses, version control can provide major benefits like:

  • Branching and merging functions that support a 'choose your own learning path' initiative.
  • Testing a particular concept within an assignment, locally, without affecting the integrity of the main or source file (known as 'sandboxing').
  • Easily sharing projects on separate branches with diverse teams, even those who are further along or further behind in a course's modules, without worrying about deleting or overwriting files.
  • Maintain a semester-to-semester record of activities, assignments, tests, and metrics (which is useful for future refining of the course, changing elements that are not accessed as much and implementing new lessons for skills that seem to be in demand).
  • Allowing instructors to introduce a new, tangential learning concept or module that, while not applicable to all users, can be accessed if the user wishes.

An Example Repository Process

To bring it all together, let's take a look at what an example repository process could look like when functioning.

Let's say, for example, that one of the assignments is to develop a series of web pages for a consulting business (and the course is 'Master Ruby' or 'iOS development for teams').

A web developer completes the assignment and commits this assignment to a repository. As part of the collaborative assignment, another team member is responsible for doing the graphics and media portion of these web pages. The designer does so, then commits these changes once more.

Next, another team comes along, later on, and uses these web pages to the design and implement their own graphics and media. Or, they like some of the main elements of the web page but want to change the code for some other elements. In this case, they would take the original web page files and commit any changes on an entirely new branch, tracking changes with a message explaining what they've changed and why.

This allows both students and course developers to watch how a networked course changes and evolves into its own map, over time. Essential for quality control, wouldn't you say?

Core Competencies

Remember that 'main' or 'trunk' we were talking about in version control? These are your 'core competencies' in digital courses.

In software development and multi-country roll-out, there is a model to help decide which parts of the application are the 'main' or 'core' features that remain standard across the board and that act as the main point of access for further, local, country-specific 'customizations'. This is called the core and country-specific model of multi-country software development.

The same holds true for and can be applied to eLearning platforms and courses.

The version control function is the mechanism through which you'll be focused on delivering core versus supplemental learning material. But the core and country-specific model is how you can decide on which skills and knowledge points should be considered core competencies, and which are country-specific 'iterations' or customizations.

Part of the process of the core and country-specific model of software development is to first start with gathering the requirements for all business units. A common set of requirements is gathered, based on a detailed analysis of an input from all business units that will be a part of the application implementation.

Just like in version control, the 'core' is developed as a common application, based on common requirements, and the regional business or 'main' trunk is managed by the core team. Meanwhile, iterations or country-specific developments are handled and tested by the local, country-specific teams.

In the development of digital learning materials, the model would be much the same. There would be a main syllabus that can be accessed by all users.

It would be managed and updated by the 'main' team. Meanwhile, country-specific teams or learners would handle and administer their own 'branches' or iterations, separately, maintaining the purity and integrity of the core competencies while allowing users and learners to develop their own paths to learning.

Version control, software development, and eLearning clearly go hand in hand. Why? Because open-source sharing is becoming the future of learning – and the fact that it can happen beyond borders, in a digital environment, simply enhances learning as a collaborative practice.

Close