"Tagging" has been a long-requested feature for managing content in Studio, and now OpenCraft is finally designing and building it for Axim Collaborative! While there are big plans, the first release will be a user-friendly, minimal viable product. Here are some of the things everyone can look forward to:
So, get ready for more organized learning content. Tagging will make it easier for you to find, curate, and build relationships between course content. Your learners will thank you too! Think of courses that are effortlessly searchable and primed for personalization.
Contact us if you’d like to know more about the project.
A feature that will be released soon is copying and pasting course content. Talk about saving content authors more time! OpenCraft is very excited to be involved in the UX and development of this project. Ultimately, the feature will allow authors to copy sections, subsections, units and components, and then paste them into different locations within the same course or into a different course. No more duplicate work - whoop!
Keep your eye on the Open edX forum for the official public release of this feature.
We’re proud to announce that during the first six months of this year, three more OpenCrafters were bestowed the Core Contributor title. We now have 13 Core Contributors!
The Open edX Core Contributor program allows members to participate in defining and deciding the direction of the platform through design, coding, marketing, and more. To become a member you need to embody commitment to the project, exemplary conduct, and high caliber contributions. Well done to the following three team members:
Code Contributors:
UX and UI Contributor
Meet our amazing Chief Technology Officer! Braden hails from Vancouver, Canada. When he’s not doing awesome things with code, you’ll catch him hiking the glorious mountains right on his doorstep.
Braden started his journey at OpenCraft in 2014. But his journey in open source started with his first contribution at age 14! He loves being a part of the Open edX community, and the community loves him! He was made a Core Contributor in 2020. Projects that have received a lot of his attention are things related to XBlocks and how they're stored, including Modular Learning and Content Libraries. In fact, he’s super happy about being involved with the Modular Learning efforts where he’s building functionality that he and the community have wanted for a long time. Braden particularly loves being involved in architecture discussions. You’ll often catch him being extremely helpful on the Open edX forum.
Outside of OpenCraft and the Open edX community, Braden likes to work on open source JavaScript/TypeScript projects. He’s a big fan of Deno, TypeScript, and Next.js. He’s also the co-founder of Neolace and TechNotes, and owner of MacDonald Thoughtstuff Inc.
As I mentioned, Braden is really active on the Open edX forum, so reach out to him there!
We’re an elite team of designers and developers, who love creating quality learning management solutions. Let’s chat about your latest project.
The fifteenth Open edX community release, called Olive, is now out! The release was coordinated by the Open edX community via the Build / Test / Release working group, and brings improvements to the Discussions Micro-frontend (MFE) and HTML component editors, but also novelties like the brand-new Authentication MFE.
You can also learn more about Olive at the upcoming Open edX Community Meetup, scheduled for 1/26/2023 at 10 AM (EDT). A registration link to this free virtual event will soon be posted on the Open edX blog.
In addition to Open edX development, OpenCraft has been working on the development of Listaflow, an open source workflow tool for remote team collaboration and reporting. In the blog post highlight below, our UX designer Ali Hugo presents the product, and explains how the early release is already being put to good use by the Open edX community. Scroll down to learn more!
The Call For Proposals for the 2023 Open edX Conference is open until January 23rd, 2023. All community members are welcome to participate and submit their ideas! To learn about the types of presentations the Community is seeking, and how you can submit a presentation proposal, please visit Sessionize. Early bird rates for conference tickets are up until early January, so be quick and buy your tickets!
The recording of the December Open edX Community Meetup can be watched online. Here's a recap of the program:
I love cooking, and I love sharing recipes. Here’s one for a simple, yet very tasty marinara sauce. It's great on everything. It's one of my secret weapons. All you need is 3-4 ingredients and a few hours' time. Share this red deliciousness with friends and family, and appreciate the small, great things in life.
User Retirement in an Open edX platform is the very last stage of the user account’s lifecycle, which begins with registration of a new user. That is, it is the thing that happens when a user clicks on the “Delete My Account” button on the Account Settings page.
However, it is not a single step, but a series of steps resulting in deactivation of the user account, removal of the user’s Personally Identifiable Information (PII) from all services making up the Open edX platform, and culminating in permanently disabling the username and email address from being reused ever again.
In this blog, we will explore how the user retirement workflow is designed, the steps involved in user retirement, different ways of triggering user retirement, and how to enable reuse of a retired username and email address.
The Open edX platform is not a single application, but a collection of services and IDAs — each handling a specific part of the user experience, such as course-discovery, discussion forum, eCommerce, etc. Each of these services maintains relevant user data to correctly handle users’ requests.
This makes the process of deleting a user from the platform complicated. Merely deactivating the user account and removing their credentials is not sufficient. User data also needs to be deleted from each of these services for the platform to be compliant with regulatory frameworks such as GDPR.
To make things more complicated, running some of these services on the platform is completely optional, with the possibility of installing custom services as well. Therefore, the retirement process needs to be configurable so that it attempts to delete user data only from services which are actually being used in the platform instance.
To address all this, the retirement workflow is designed as a linear pipeline, where the user deletion request moves through a series of fully configurable States.
When a user retirement is initiated, an entry is created in the UserRetirementStatus model, with the state set to PENDING. This is the very first state of the Retirement Pipeline.
In this step, hash values of the username and email address respectively are generated and stored in the UserRetirementStatus model along with the original username and email address. The email address in the User model is replaced with its hash value and the password is reset. This prevents the user from logging into the user account.
At this PENDING state, it is possible for the site administrator to cancel the retirement workflow if so requested by the user. This can be done either by using the cancel_user_retirement_request management command or by clicking on the ‘Cancel’ action button in Django admin. This restores the email address in the User model and deletes the entry from UserRetirementStatus. Cancellation of retirement workflow is not possible in any other retirement state.
The user then moves through a series of unique pairs of retirement states, each indicating that a stage or action of the retirement workflow is either underway or has been completed.
RETIRING_FORUM and FORUM_COMPLETE is one such retirement state pair. Here the RETIRING_FORUM state indicates that the forum retirement API has been triggered and deletion of user data from discussion forum service is underway and the FORUM_COMPLETE state indicates that the API has been successfully executed.
Any number of such pairs of retirement states can be configured and in any order, however each RETIRING_SERVICE state should always be succeeded by the corresponding SERVICE_COMPLETE state.
The COMPLETED, ERRORED, and ABORTED are the dead end states. That means the retirement workflow cannot proceed any further from any of these states. The dead end states, along with the PENDING state need to be mandatorily configured with all other states being optional.
The COMPLETED state is the very last state of the retirement workflow, indicating that all configured stages of the retirement process have been successfully completed.
At this state, the username is replaced in the User model with the hash values generated previously. However, the entry in the UserRetirementStatus model still contains a mapping between the hashed username/email address and the actual username/email address of the user. The retirement_cleanup API can be used to delete this entry, thereby completely removing the user’s original username/email from the platform.
The retirement workflow moves to the ERRORED state for one of two reasons — either there is an execution error during one of the retirement stages, or there is a discrepancy in the retirement states (such as the user moving from one state to a previous state).
A site admin can look into the cause of the error, fix it, and then manually move the user to a correct state, which would enable the resumption of the retirement process.
The default list of the retirement states is defined in lms/env/common.py
This list can be configured by setting the RETIREMENT_STATES variable in /edx/etc/lms.yml
The active Retirement States are maintained using the RetirementState model.
Each state has an Execution Order Number, which determines the order of the states in the workflow. Any violation of this order of execution during the retirement process will lead to an error with the user moved to the ERRORED state.
The populate_retirement_states management command can be used to populate the RetirementState model or override the states which are already configured.
There is currently no out-of-the-box mechanism in Open edX to drive this retirement workflow.
Therefore this needs to be driven from an external service, or the tubular scripts can be used to either trigger the workflow execution manually or set up as a cron job to execute workflow at regular intervals.
There are a number of ways in which user retirement can be initiated:
As mentioned previously, the generated hash value of the username and email address, is used to replace the corresponding original credentials in the User model at different stages of the User Retirement Workflow.
As part of the validation process during user registration, the hash value of the new username and email address is calculated and queried against the User model to check if those hash values are already present. If so, the validation fails and the user is requested to choose a different username and email address. This is how the platform ensures that a retired username and/or email address is never reused.
There may be certain use cases, however, where the reuse of the retired user credentials would be desirable or even necessary. We here at OpenCraft encountered one such use case for one of our clients. This client used a third party external service for user management. That means, the client’s users would register, manage and deactivate/delete their accounts in a third party UI, and that service would use the correct APIs of the Open edX platform in turn to register and/or retire the user accounts in the platform. Now, using the third party service, it was possible for the client’s users to delete an account and then create another account using the same credentials. However, the user registration API in the Open edX platform would throw an error when using the retired credentials. This was a big problem for our client.
We looked for an existing solution to this problem and, not having found anything, we set out to design a solution for this problem ourselves.
There were a few considerations during the design of the solution:
This led us to create the enable_retired_username_email django app.
This app is designed to be installed along with the Open edX installation using pip:
pip install -e git+https://github.com/open-craft/enable-retired-username-email.git@v1.0#egg=enable-retired-username-email
Or by setting the EDXAPP_PRIVATE_REQUIREMENTS variable while installing the Open edX platform using ansible.
This app receives the post_save signal from the UserRetirementStatus model, and does one of two things:
COMPLETE state, a hash of the string <email_id>+<current_timestamp> is calculated. This email address in the corresponding User model, which now contains the hash of the original email address, is replaced with this new hash value. The entry in the UserRetirementStatus model is deleted, thereby removing all traces of the original credentials and its corresponding hash values.Voilà! We hope this is useful, and let us know via comments below or at contact [@] opencraft.com if you have any comments or questions!
Photo by Tandem X Visuals on Unsplash
This article was co-written by OpenCraft team member Adolfo Brandes and Daniel Seaton, Sr. Learning Systems Designer at MIT.
In this article, we'll describe how problems, videos, and pages from Open edX courses can be reused on the Canvas LMS via a new LTI implementation in Libraries v2, a feature recently developed by OpenCraft for MIT Open Learning. This project builds upon a wider effort commissioned by edX to enhance LTI compliance (1,2) and build more flexible and robust content libraries (1) for the Open edX platform.
Before getting into the details, let's dive a little on why this was done in the first place.
If you've ever authored courseware, you know how difficult it is to produce quality content. And if you spend a lot of time doing it, chances are you'll end up with an extensive library on a particular platform, such as Open edX courseware. What happens, though, when you want to reuse that content elsewhere? Few people would relish rewriting everything from scratch!
There are different ways a platform can allow content to be reused. The most common is by letting data be exported. This has been possible in Open edX since its inception: one can export courseware using the Open Learning XML format. But while it's straightforward to import the resulting tarball into a separate Open edX instance, bringing this content into another platform altogether presents a series of challenges:
Luckily, an organization called the IMS Global Learning Consortium came up with LTI, which aims to solve the issues above. LTI is short for "Learning Tools Interoperability": as long as both platforms support it, you can simply point the target platform to the source, and voilà! The learner will be able to interact with your painstakingly created content transparently, no import necessary. Best of all, if you make changes to the original content, those changes will be reflected anywhere you have reused it.
Open edX has been able to act as an LTI provider for a long time, and Canvas has correspondingly been able to consume from Open edX courses on a block-by-block basis. What else was needed, then?
Here's the thing. Reusing content originally written as part of a regular course is clunky at best. There are difficulties with content structured in this manner, particularly when it comes to Open edX:
It is for these and other reasons that Content Libraries development began in 2019. (OpenCraft CTO Braden MacDonald gives a great overview of the motivation behind this push, which includes the Blockstore backend, in this video.) With better search features and making grouping of related content much easier, they’re designed to support content reuse within Open edX courses.
The catch? As of early 2020, Open edX Content Libraries did not yet support any kind of LTI integration. While it was possible to reuse library content from within an Open edX instance, you couldn’t do so externally.
MIT, by any measure, is a heavy user of Open edX, maintaining an instance solely for on-campus teaching and learning. The instance has hosted over 200 unique courses for MIT students, leading to more than 35,000 unique problems, 15,000 unique videos, and 23,000 pages. The on-campus instance of Open edX is not the primary LMS at MIT, but exists as an optional system for creating enhanced, blended learning experiences.
In Fall 2021, the Canvas LMS was introduced at MIT to replace a homegrown, legacy system that did not offer the features of a modern LMS. Given the extensive library of rich content on MIT’s on-campus Open edX instance, the introduction of Canvas created new opportunities to think strategically about content integrations between the two platforms. MIT approached OpenCraft about their recent work on Content Libraries with Blockstore and began formulating a starting point to address broader ambitions related to content interoperability.
In short: MIT needed LTI for Content Libraries. So, over a few months at the end of 2021, OpenCraft built not only a way for Canvas to use LTI to integrate Content Libraries, but a way for authors to import content from preexisting courses into Content Libraries. The current implementation allows single xblocks (e.g., a problem, video, or page) to be reused via LTI.
Instead of just describing the new features, let’s show you how to actually use them with the Open edX and Canvas development environments. (The steps below require you to set up a local Open edX devstack and a local Canvas development environment.)
To start, set up your Open edX devstack with the Libraries v2 frontend and Blockstore backend, as outlined in Library Authoring project README. Then proceed to set up a Canvas development environment using the automated setup described in its Quick Start guide. We won’t walk through individual steps in setting these environments up, as that would be beyond the scope of this post. Worry not, though! The corresponding setup procedures are well documented in each project.
From this point on we’ll assume you were able to set them up successfully, including being able to access:
Continue by logging into your local development instance of Canvas as an administrator, and creating a Developer Key. You can do so from the Admin > Account panel, as shown below:
To start creating the key, click on + Developer Key, then + LTI Key, like so:
On the "method" drop-down, select "Paste JSON", and copy/paste the following into the text box (you could fill fields individually, but this makes it easier!):
{
"title": "edX Content Library",
"scopes": [],
"extensions": [
{
"platform": "canvas.instructure.com",
"settings": {
"platform": "canvas.instructure.com",
"placements": [
{
"placement": "assignment_selection",
"message_type": "LtiDeepLinkingRequest"
}
]
},
"privacy_level": "anonymous"
}
],
"public_jwk": {},
"description": "edX Content Library",
"custom_fields": {},
"public_jwk_url": "http://127.0.0.1:18010/api/libraries/v2/lti/1.3/pub/jwk/",
"target_link_uri": "http://127.0.0.1:18010/api/libraries/v2/lti/1.3/launch/",
"oidc_initiation_url": "http://127.0.0.1:18010/api/libraries/v2/lti/1.3/login/"
}
Note: the last three URLs point to Studio on your local Open edX devstack.
Give the key a name, such as “Open edX Tool”, and save it. Then immediately enable it by clicking on its ON button as shown below, and copy the client ID (“10000000000001”, here) to your clipboard.
Now we’ll add an “App”. Go to Site Admin > Settings, and on the Apps tab, click on the + App button. Choose the “By Client ID” configuration type, and paste the client ID from the key you created above:
After clicking Submit, confirm you want to install the app by clicking on Install. You should now see an “edX Content Library” app in the list of external apps.
Click on the app’s configuration icon, then on Deployment Id. You’ll need the identifier (here, “1:8865aa05b4b79b64a91a86042e43af5ea8ae79eb”) when setting up Open edX, so copy it to the clipboard.
Start by enabling the content libraries LTI tool for Studio. You’ll need to edit the Features setting from the Studio container itself:
cd devstack
make studio-shell
vim /edx/etc/studio.yml
...
FEATURES:
ENABLE_CONTENT_LIBRARIES_LTI_TOOL: true
Save the file, exit, and restart Studio via:
make studio-restart
Next, you’ll need to pre-generate a JSON Web Token keypair as a means for Open edX and Canvas to trust each other. An easy way to do it from the command line using SSH and openssl is:
ssh-keygen -t rsa -b 4096 -m PEM -f jwt.key
openssl rsa -in jwt.key -pubout -outform PEM -out jwt.key.pub
cat jwt.key
cat jwt.key.pub
Note the contents of each file, as you’ll need them shortly.
Now log into Studio as an administrator, then proceed to the Django admin interface at the following address:
http://localhost:18010/admin/lti1p3_tool_config/
Click + Add on the “Lti 1.3 tool keys” entry, give it an arbitrary name, and paste the corresponding keys you created above. In other words, under “Private key”, paste the contents of jwt.key, and under “Public key”, paste jwt.key.pub, like so:
Once the key is saved, go to the list of LTI tools at:
http://127.0.0.1:18010/admin/lti1p3_tool_config/ltitool/
Click on ADD LTI 1.3 TOOL on the top right, and fill the fields with the corresponding information:
That’s it! When you click save, Open edX Content Libraries and Canvas will be set up to communicate with each other via LTI.
What’s left to do is to actually create a content library with some content in Open edX, and to finally consume it in the Canvas instance.
Start at the Open edX library authoring frontend, which in the devstack setup is located at:
http://localhost:3001
Click on New Library, filling the fields out as you see fit: the library details are arbitrary. Just make a note of them for later! For instance:
After submitting, add a “Poll” block by clicking on the Advanced button, then on Poll. (For the purposes of testing LTI integration, you don’t need to customize it, but feel free to do so by clicking on the block’s Edit button.) The block should be visible in the library you created, like so:
Next, you'll need to explicitly allow this library to be shared via LTI. For now, the only way to do so is via Studio’s admin interface, at:
http://127.0.0.1:18010/admin/content_libraries/contentlibrary/
Click on the library's ID (in this case, "library01") to edit its metadata. Under "Authorized LTI configs", simply click on the first "LtiTool object" (which refers to the LTI configuration that points to Canvas you created earlier) so that it remains selected:
Click Save, then go back to the library authoring frontend and the library you created (here, http://127.0.0.1:3001/library/lib:DeveloperInc:library01), and refresh the page. You should now see a "Copy LTI URL" button alongside the poll block you just created.
The presence of the Copy LTI URL button is confirmation that this library is accessible via LTI. Click on it: doing this will copy this block's LTI integration URL to your clipboard.
Instead of creating blocks from scratch, you can also import them from a preexisting course into a library. To do so, go to the library’s Settings menu, and click on import:
Next, click on Show Importable Courses, then import the Demonstration Course by clicking on its Import Course button. After a few seconds, the import should be completed:
If you then go back to the library page, you should see a list of all the imported blocks, all of which could also be used via LTI:
Now, go back to the Canvas Dashboard and click on Start New Course. Give the course any name you like, then from its home page click on Assignments, then + Assignment to create a new (you guessed it!) assignment. Its name is also arbitrary (we're calling ours "Open edX Poll"), but under "Submission Type", choose "External Tool". And for External Tool URL, paste the LTI URL that's on your clipboard. In our case, it looks like this:
http://127.0.0.1:18010/api/libraries/v2/lti/1.3/launch/?id=lb:DeveloperInc:library01:poll:c3fe9810-3811-4794-878f-da08ca07ff00
Click on save, and… That's it! Your Canvas learners should now be able to interact with the poll block from within a Canvas course, just as if they were using it inside Open edX. And yes, this includes grading!
Note: LTI urls can also be used in an <iframe> in any Canvas Page, which is great for embedding videos, pages, and other non-graded content. An easy way to try this is by including an LTI url, for a video or page, within the content editor for an assignment. You can include an <iframe> with an LTI url anywhere you can access the Rich Content Editor in Canvas.
It's still early days for Open edX Content Libraries, but the fact that Library items can now be used via LTI integration opens up a realm of possibilities. Because libraries are unbound from the traditional courseware structure, they allow more effective content reuse. And because their content can be accessed programmatically, it can be used in all kinds of interesting ways, for instance, for adaptive learning. In addition, Libraries offer an easier entry point to the vast array of Open edX problem types. Allowing instructors to start their authoring journey from a Library might make for an easier introduction to the power of the Open edX platform.
If you’d like to know more, let us know!
Header image: "Canvas Skies" by Nichole Renee is licensed under CC BY 2.0
A good way to assess learners in online courses is to evaluate essay-type text responses through a set of well-defined quantized criteria (called rubrics).
The Open Response Assessment (ORA) is a component available in the Open edX platform that allows creating free-text input and offers a variety of evaluation methods based on rubrics: peer-graded, staff-graded, or self-assessment.
In early 2020, edX decided to improve the usability and user experience of the ORA block, as well as implement new features through a blended development project with OpenCraft.
Blended development projects are funded by edX to implement roadmap features and promote collaboration between edX teams and partners in the community while increasing edX’s development throughout. You can find more information about these projects in the Blended Development Runbook.
Here is a summary of the improvements that were made as part of the development project:
Many changes on this project were aimed at making the ORA authoring experience easier and simpler for instructors. The ORA block is now displayed as a top-level block in Studio, and offers some pre-configured templates.
The ORA configuration menu was improved. The schedule and assessment steps settings were moved to separate tabs to simplify the user experience. The assessment steps tab now allows easy configuration of the evaluation steps and hides unnecessary settings. The schedule tab handles all dates and deadlines settings separately.
When peer assessment steps are enabled, it’s common for some students to get stuck waiting indefinitely, especially at the start or end of a course, when there’s not much activity. Students in this state are either waiting for peers to grade their assessment or waiting for assessments to be graded.
One of the new changes is a screen in the instructor dashboard that displays a list of students stuck in the Waiting step and allows instructors to override grades and apply staff grading directly from that screen.
You can read more about this feature on Accessing Metrics for ORA Assignments.
Previously, ORA data reports were hard to use since no human-readable user information or block was exported. This left instructors to map students using the exported anonymous user ID manual outside of the platform. On this project, they were improved and now include the real username (instead of only the anonymous ID username), block id, and the readable problem name. This makes it easy to interpret the files, parse submission information, and map this data to actual students.
Additionally, there’s a new report in the Data Downloads tab that allows downloading of all responses submitted by students for offline grading. See the detailed documentation for this report on Accessing Metrics for ORA Assignments.
Learners will now be able to submit nicely formatted answers through a WYSIWYG editor instead of plaintext submissions.
See Create an Open Response Assessment Assignment for information on how to set this up on your instance.
Additionally, peer assessment steps (assess peers and waiting for peer assessments) are now non-blocking, allowing students to assess their own response and get a staff grade at any time in the process.
These improvements were developed and merged to the master branch of Open edX: they are partially available in the Koa and fully available in the Lilac release. Check out the Open Response Assessments documentation for details and detailed usage instructions for the new ORA features.
If you want to start using the latest ORA improvements, you can try OpenCraft's Pro&Teacher offering free for 30 days. You'll get a fully dedicated Open edX deployment running on the latest release of the platform.
This article was written by Giovanni Cimolin (OpenCraft) and Ned Batchelder (edX).
Learning Tools Interoperability® (LTI®) is a standard used to integrate different learning platforms and tools and allows a richer learning experience through the use of graded problems, interactive content, and third-party applications.
LTI support in the Open edX platform opens a wide range of possibilities for learning content. Because of LTI’s broad adoption across ed-tech platforms, there are hundreds, if not thousands, of tools available that can be integrated into Open edX courses. LTI tools are available from a wide range of organizations, from large ed-tech vendors to universities building their own integrations.
In Open edX software, LTI is used in two ways: as an LTI consumer in courses to enrich the learner experience by embedding interactive problems and exercises from external sources, and as an LTI provider to allow other LMS’s to embed Open edX course content.
In 2018, IMS introduced the new version of the LTI specification (LTI 1.3) focusing on modernizing the LTI standard, improving security, and enabling a flexible and extensible specification. The Open edX platform has long supported the 1.1 version of the LTI specification. Adding support for the 1.3 specification version brings the Open edX platform up to date with the most capable LTI standard.
You can read more about the advantages and improvements of the new standard in Why Platforms and Tools Should Adopt LTI 1.3.
Early in 2020, edX decided to implement LTI 1.3 in the LTI consumer support through a blended development project with OpenCraft, and then followed up with another project to implement the LTI Advantage extensions (detailed in the next section).
Blended development projects are funded by edX to implement roadmap features and promote collaboration between edX teams and partners in the community while increasing edX’s development throughout. You can find more information about these projects in the Blended Development Runbook.
LTI Advantage is a set of extensions to the LTI 1.3 specification that enhance its capabilities and allows deeper integration between LMS and LTI tools. Its two main goals are (1) to enable deeper integration between tools and platforms, avoiding the need for custom integrations, and (2) to provide a secure channel to transmit student and enrollment information.
LTI Advantage includes three services, detailed below.
The Assignments and Grades service (LTI-AGS) allows LTI tools to send and manage learner grades back to the platform.
When LTI-AGS is enabled and the component is set as graded in an Open edX course, grades sent from the tool will be automatically linked to the student gradebook. The LTI tool may also manage, edit, and override student’s grades directly, and provide reports on the user status of the activity (pending, started, fully graded).
You can enable this feature on your instance following the Assignments and Grades service setup documentation. Make sure you set up an LTI 1.3 integration in your Open edX instance first. For more information, you can follow the official LTI component documentation.
The Deep Linking service (LTI-DL) allows course creators to select and configure the content displayed to learners through Open edX Studio. This removes the need to use custom parameters and settings when setting up content, improving the ease of use and content authoring experience.
For example, a tool may let course creators configure a link that will launch a specific chapter from a book rather than displaying the full book and having students manually scroll to that chapter.
You can enable this feature on your instance – just follow the deep linking service setup documentation.
The Names and Roles Provisioning service (LTI-NRPS) allows tools to list and retrieve information about the learners that have access to an LTI component. The tools can retrieve a limited amount of personal information (full name, email, username) and the membership status of all the learners enrolled in the course.
A tool that uses LTI-NRPS will be aware of all users with access to that tool and can provide reports on student activity within the tool. For example, a tool might display a report of enrolled active users that haven’t started an activity.
With the implementation of the LTI Advantage services, the Open edX platform has been formally certified as LTI Advantage Complete (more details on Open edX platform earns LTI® Advantage Certification).
LTI 1.3 and LTI Advantage features are available in the Lilac release of the Open edX platform.
If you want to start using LTI 1.3 and LTI Advantage extensions right away, you can try our Pro&Teacher offering free for 30 days. It’s a full dedicated Open edX deployment running on the Lilac release of the platform.
LTI® is a trademark of IMS Global Learning Consortium, Inc. (www.imsglobal.org)
Cover photo by Tamanna Rumee on Unsplash
This blog post was co-authored by OpenCraft team member Usman Khalid and edX team member Dave Ormsbee.
It is with great excitement that we're announcing that all the XModules in the Open edX platform have recently been converted into XBlocks.
XModule was the original framework for course components in edx-platform, and the predecessor of the XBlock framework. When the XBlock framework was introduced into edx-platform in 2013, because of the numerous XModules in use, a compatibility layer was written to allow an incremental transition to the new framework. This compatibility layer allowed the XModule infrastructure to run XBlocks and for XBlocks to see the XModule infrastructure as the XBlock Runtime.
XModules and XBlocks had different life-cycle properties and in some cases different APIs for the same features. This transition state was dubbed “peak confusion” by the edX engineering team to express the idea that it would be an extremely confusing time for the courseware internals, but that we could eventually come down from that complexity once XModules were removed.
Over the years a number of lesser-used XModules were deprecated and removed. In 2015, the Vertical XModule was converted and in 2016 the Discussion XModule was converted.
When the Blockstore project was started, the decision was made that it would only support XBlocks and a new XBlock Runtime was written for it. As part of the work, the Video, HTML and Problem XModules were converted to XBlocks.
The remaining fifteen XModules have been converted to XBlocks through a months-long blended development effort by OpenCraft and the edX T&L team.
With the system now only hosting XBlocks and not constrained by having to maintain backward compatibility with the old framework, it becomes possible to significantly simplify the courseware internals. This will make the system a lot more approachable for developers and significantly reduce the complexity of big jumps in capabilities of courseware.
We are looking forward to seeing these developments in the future!
Photo by Hunter Harritt on Unsplash
Arguably, one of the biggest things about the most recent Open edX release, Koa, is that it officially supports the deployment of (some of) the newfangled micro-frontends edX has been putting out. Among them is edX Publisher, also known as frontend-app-publisher, and we at OpenCraft feel it warrants some introduction in addition to what’s in the README - much like we did for the Gradebook MFE.
(You’ll see this post duplicate some of what’s in the README. Don’t sweat it, we’re not plagiarizing; we wrote that too!)
Contrary to some of the Open edX IDAs, running Publisher is completely optional. As such, it may not be easy to decide whether you have a pressing need for it. This post’s raison d'être is to help you decide. (And if the text doesn’t live up to it, it’ll at least tell you how to try it out for yourself!)
Let’s start by looking at what Publisher is not.
You guessed it. Publisher is not a course authoring tool. And it definitely doesn’t replace Studio for the editing of course content.
However, it does fill the same niche that some Studio features do, particularly as they relate to creating and editing course metadata. Put simply, if you use Publisher, you’ll no longer use Studio when creating courses, configuring their settings, writing about pages, and instantiating course runs. You’ll do so via Publisher - but will still go to Studio to flesh out course content.
edx created Publisher primarily to make it possible for courses to undergo a draft, review, and publish cycle, in a workflow that resembles Github reviews:
This is not all, though. In implementing the above, Publisher also:
Publisher is most useful for organizations that:
If your organization doesn’t fall into one of the above, Publisher can still be useful but will likely not be considered mission-critical.
Sure thing! Let’s start by using it on a devstack. It’s rather easy: just follow the devstack setup instructions. The default setup will get you a basic frontend-app-publisher instance all ready to go!
Once your devstack is up and running, open a browser and direct it to https://localhost:18400. If you’re not already logged in to the LMS, use the default “edx@example.com” account, with password “edx”. Once in, this is what you’ll see:
Note: If you get a connection reset error, the MFE likely did not finish compiling. It's sensitive to slow internet connections, and does not like being behind a proxy. Check if it was compiled correctly via make frontend-app-publisher-logs.
You might recognize the demonstration course: this is the same one that has shipped with the devstack for as many years. And above it, note the ability to create a new course, filter by status (“In review”, “Published”, “Scheduled”, and “Unsubmitted”), and search by name. Quite an improvement over Studio!
If you click on the demonstration course, you’ll see a page where you can edit the course’s metadata and create runs.
Not really, no. This is just a presentation-layer feature that makes it easier to manage metadata. From the point of view of the learner using the LMS, it’s still all runs.
They’re much easier to create with Publisher, though. Simply click on “Add Course Run”, and after configuring it, you’ll see it “Unpublished”, like the Jan-25-2021 one you can see above. After you set all the run’s metadata, you can submit it for review by course staff with the click of a button:
This is probably enough for you to get the gist. For a more detailed feature-by-feature guide, refer to the Introduction to Publisher chapter of the courseware development documentation.
Note: Can’t get comments working? That’s probably because to do so you must first configure integration with Salesforce. See this decision document in the course-discovery repository. In essence, if you don’t have a Salesforce account, you’re out of luck.
As an MFE, Publisher must communicate with other Open edX IDAs to do its job. The three whose APIs are consumed directly can be gleaned from its default environment files: LMS, Studio, and Discovery. The first two are a given, but for proper functioning of Publisher one needs to set up Discovery. Discovery must be made aware that Publisher is in use via the ENABLE_PUBLISHER setting. It will then be responsible for integrating course runs into other Open edX services such as eCommerce and Programs.
Both Studio and the LMS use of the same ENABLE_PUBLISHER setting, but its primary effect is to forbid the editing of course about pages in Studio. (The relevant fields actually disappear from the /settings/details page for a course.) This makes sense, as producing about pages is Publisher’s main purpose, after all.
Can’t get Publisher to work, or want a demonstration? Get in touch! We’ll lend you a hand!
This article was written by team member Adolfo R Brandes.
Cover image: "Print press" by Herkie is licensed under CC BY-SA 2.0
If your company runs a copy of the Open edX platform, you may feel satisfied with its impressive array of features. However, keeping an up-to-date installation is essential for several reasons. You would not want to end up facing security issues, being stuck with old bugs, or missing out on great things the platform has to offer. By the end of this article, I hope to convince you that you should upgrade your Open edX installation when new releases arrive.
Open edX puts out 'named release' upgrades. They name each version of the platform after a tree (or family of them). Aspen, Birch, Cypress, and so forth. Each one comes with its own upgrade guide, like this one for the most recent release, Koa. Only the latest release is supported, however.
At OpenCraft, we provide hosted installations of the Open edX platform. All of our customers receive these upgrades as part of our service plans. If you're going it on your own, or you just want to know why you should keep up to date, keep reading!
If you've not upgraded your Open edX installation in a long while, your installation has security vulnerabilities. To keep the data of your staff and students safe, upgrading is essential. Like most open source projects, the Open edX platform has many dependencies. On the LMS's code alone, the base requirements include over 240 packages.
Any package could contain vulnerabilities, and that's not considering the platform's own code. While the code quality standards within the platform are top-notch, even with great vigilance, security patches roll out. In fact, the Juniper release had two security upgrade releases after its initial debut. Patches are a normal part of running any web application, so be sure to have an upgrade plan in place!
The most exciting reason to upgrade your Open edX installation is new features. The practice of online learning evolves-- and so do the tools for it. Open edX's latest releases have heavily focused on Micro Frontends-- which work great on mobile devices. Micro Frontends are independently deployable JavaScript applications that use modern web technology to streamline the learning, authoring, and teaching experiences. They can add features much faster than the traditional user interface, and they are the future of the Open edX platform. One example is the new editable gradebook.
Another improvement in the Koa release is an improved ID verification workflow, which helps you and your team ensure the integrity of proctored exams. Personalized learning schedules arrived as well, letting you tailor due dates to learners' individual circumstances. On top of this, celebratory milestones have been added, to give an extra bump of encouragement as learners progress through the course. These additions, and many more, demonstrate how upgrading your Open edX installation allows you to meet the changing demands of modern education.
If you ever have an issue with your Open edX installation, or you want to know how to do something, you'll want to talk to people who know your system works. Since the Open edX community only supports the latest named release, you'll want to have it (or be working to upgrade to it) when you post on the community forums or their Slack channel.
Software developers working on the Open edX platform use the devstack, which is constantly evolving. This means that it can be more difficult to build software solutions for old versions of the platform, and that makes getting custom improvements or XBlocks written for it more expensive.
Concerned that your install has fallen behind and not sure how to begin the upgrade process? We at OpenCraft can help you update your Open edX install-- even if you've got a complicated or custom setup. We work with some of the biggest names using the edX Platform, including Harvard, Australian National University, Cloudera, Autodesk, and, of course, edX themselves.
The edX.org website opened in 2012 as a massive online learning destination with free courses that anyone could enjoy. Today, edX® tracks hundreds of thousands of learners. When the Open edX platform was released in 2013, the need to serve large audiences drove its features.
A system oriented around such large course sizes needed to manage grades in a consistent, predictable way. With little intervention, the system successfully handled scoring. As time has gone on, the cost of running an instance has gone down. Thankfully, you can now start your own LMS within a couple of hours. Online learning has proven itself, and continues to grow, demanding more versatility.
To keep grading simple, edX problems score automatically via course components. You answer a question right, and you get the points. Answer it wrong, and you don’t. This works great for massive courses– but it’s less helpful for smaller ones, or ones that offer more direct advisement. Instructors need the ability to override grades based on circumstances. Extra credit, technology issues, and personal assessments are all examples of when changing a grade is helpful.
Recognizing these needs, the Open edX team has begun work on a new editable gradebook. It is not yet available in a vanilla Open edX deployment, but it can be installed on any up to date instance. Let’s take a look at what the community built so far.
You can skip this if you’re not technically oriented, or just want to see what the editable gradebook looks like.
The Open edX community is developing ‘micro frontends’ like the gradebook. Micro frontends allow for more flexibility and rapid development of features that affect user experience. These React-based frontends use REST calls to the backend to provide a modernized experience.
This is an improvement over backend template rendering, as the frontend no longer requires the backend's instructions on how to arrange the page. As a result, we can use modern Javascript tooling.
Micro frontends aren’t easy to set up in production, but if you’re familiar with the edX devstack, you can play around with them by following the instructions in their README. Follow the instructions carefully– the gradebook may run but exhibit strange behavior if you do not. This project is still new.
The new gradebook shows all of your students and their grades. You can rapidly filter through students by using a search bar in the upper right corner of the screen.
To modify an exercise, you click the grade.
You can enter a new grade here, along with a reason. This allows an audit trail so you can remember who changed what grade, and why.
If you have many exercises and grades to look through, you can narrow them down using a filter panel:
You can filter by tracks, cohorts, and current score. You can also filter by the assignment type (homework or exam) and the particular assignment.
You might ask, how does the current (legacy) gradebook compare with the new, editable one?
The legacy gradebook shows you an overview of the grades, much like the new one does.
However, there’s no option to edit the grades on the current interface. When you click on a learner’s name, you are simply taken to their progress page, with no option to edit the grade.
The new gradebook currently doesn't provide individual links to each learner's Progress page. But other than that, the new editable gradebook handles everything the legacy gradebook does, and then some!
The new editable gradebook offers many feature advantages over the old one. If you have a need for more fine-grained control over grading, it’s definitely worth a try! We’ll be covering more of these Micro Frontend projects as time goes on.
Since the editable gradebook is not available on a vanilla Open edX deployment, we're happy to install it for you. Simply drop us an email at contact@opencraft.com : )
Photo by Green Chameleon on Unsplash
One of the strengths of Open edX is its support for plugins called XBlocks that enable the creation of rich new kinds of content. Through XBlocks the Open edX platform can support interactive content that greatly expands the platform's capabilities. XBlocks have been used for all kinds of things, from adding a simple border around some content, to adding support for LTI to the platform. OpenCraft has had the opportunity to work on and create some great XBlocks, and we'll be taking a look at one of them in this post.
The Chatbot XBlock is perhaps one of the smaller and lesser known of the blocks we have developed, but we hope this highlight will bring to the attention of more people. The Chatbot XBlock describes itself as "an XBlock that allows learners to chat with a bot, where the bot follows a script and the learner can choose among possible responses."
The block is presented to students as a chat conversation with an interface that mimics the visual language of chat applications with bubbles of text pointing at different avatars. Students can pick from a number of pre-written responses. The simulated conversation will flow based on what response a student selects.
At a basic level the block allows you to create conversations by breaking them down into a series of individual interactions, or steps. Each interaction or step will support one or more messages along with select responses. If there are no responses, the conversation will automatically move on to the next step. If there are responses, the user can select one of them and the conversation will branch accordingly.
Conversation from the bot side can also include images, and feedback notes that can tell the user if their response was correct or not.
Course authors can use a a simple YAML-based syntax, to design complex, branching conversation with students which they can use to explore a subject in a more interactive way. For example, in a History course, a bot named "Churchill" asks a learner a few questions about World War II, and provides different pieces of information depending on the learner's answers.
The syntax for designing these conversations supports a number of features that allow the conversation to seem more natural, and to split, merge and loop back if needed. For example, the syntax allows a number of more advanced features such as:
Currently, the only way to design these steps is through a special YAML-based syntax, however it follows a pretty straightforward format that should be easy to read and write. Here is a sample that uses most of the features (note any text following a # symbol is a comment):
The chat block can be a pretty useful tool in introducing concepts, asking questions, or giving feedback that are better done in a conversational format.
You can find out more about the Chatbot XBlock, and get a detailed overview of the syntax by visiting its repository on GitHub.
We can also install the XBlock for you and provide support as needed. Write to us at contact@opencraft.com if you have any questions!
This article was written by Giovanni Cimolin da Silva - Open Source Developer.
A few months ago we decided to rebuild our Open edX instance manager frontend to provide more customization options and features to our Pro & Teacher plan subscribers and trial users.
We needed to go from a simple registration form (shown below) to a full user console with theme customizations, LMS previews and other features.
From the start, the main goals of the project were: implement a new user console to allow users to self-service and enable our developers to work on the newer technologies that the platform is transitioning to.
We’ve opted for a decoupled implementation between the frontend and the backend using React and a REST API.
Changes made to the backend took form mostly as APIs to the new frontend, but we had to add some deployment hooks to allow passing custom configuration to the instance in provision time. drf-yasg handled the automatic generation of documentation.
The new frontend was built from scratch using React and Typescript. A TypeScript API client was generated using the backend's automatic documentation, using Swagger Codegen and saving us lots of development time.
While building the console, we leveraged a lot of features contributed over the years to the platform:
After a few months of implementation, we finally deployed our brand new user console:
Feel free to try it out on https://console.opencraft.com, and you can even deploy your own from the source code! The entire instance manager is open source software and can be found at: https://github.com/open-craft/opencraft, and if you want to dig deeper, you can follow the PR trail on the implementation.
There’s still lots of improvements to be worked on and bugs to be fixed, so if you have any suggestions, feel free to create an issue on the repository or comment below.
This article was written by Jeff Miller, a member of the OpenCraft marketing team.
We’ve consciously built OpenCraft on four values: Openness, quality, commitment and empathy. When it comes to quality, especially when it comes to ensuring the best privacy, security and flexibility for our users, we don’t do half-measures.
We work as hard as we can to ensure that our clients get the best possible Open edX development we can deliver. And that commitment doesn’t stop with custom code development. We also host instances of Open edX for our clients, and each of them is logically separate from all the others.
We only host "dedicated" instances of Open edX, which means that each instance that we deploy belongs to a single client. At the entry-level price range, other vendors offer hosting on Open edX sites, which are hosted on a shared instance along with other clients.
With a shared instance, multiple clients share the same resources, from the database to APIs. When you have a dedicated instance, the server belongs to you and you alone, and ownership confers many advantages. Let’s go through the most important of them: security, scalability and performance, data portability and control, and flexibility and customization.
Our instances are hosted on highly automated and robust cloud infrastructure, with a design and deployment strategy that has been optimized specifically for hosting Open edX, following industry-leading practices for performance and security.
With a dedicated instance, our clients never have to worry about performance lagging because another client is hosting a class with hundreds of simultaneous users and it’s hogging more than its fair share of resources.
If you need to scale up on a shared instance, it can be done, but it's impossible to predict when multiple users of the same site might have a lot of traffic at the same time, which means shared instances aren't scaled to handle the full load for each individual site they contain. In a nutshell, you end up with less available resources than you’ll probably need to handle traffic spikes. With a dedicated instance, you’ll always be able to scale to your own needs, so you can have as many courses and users as you like.
Security is also stronger with a dedicated instance. Security flaws or admin errors on one site on a shared instance can affect everyone else. For example, admins on a shared site could elevate their privileges on other sites from the same instance, which opens up all kinds of unpleasant possibilities. And if one XBlock on a shared instance has a security hole, everyone whose site is on that instance is vulnerable. By controlling your own instance, you don’t run the risk of suffering the consequences of your “roommates’” mistakes.
If you’re on a dedicated instance, the data belongs to you, and it’s easy to extract or migrate it to another host. But that’s a very tricky task if you’re on a shared instance, because you share a database with every other site on that server. Your data is all mixed up with everyone else, and extricating yours from the shared database will require a ton of expensive, time-consuming work. It’s the ultimate form of vendor lock-in. Once your site is on a shared instance, it’s very unlikely you’ll be able to leave, and if you try, you’ll be in for a terrible case of sticker shock when the bill arrives.
On a dedicated instance, you have complete administrative control, which can save you a lot of headaches. You have direct access to the Django admin console and to the database and APIs, a level of access that’s very restricted on shared instances. If you want to make even minor changes to your site on a shared instance, often the only way to get it done is to make a support request. A task that could take five minutes for you to complete on a dedicated instance takes a day or two because your ticket has to wait in the queue for an available admin. More than once we’ve had clients come to us because they were tired of having to ask their vendor to handle issues they could have easily handled themselves.
At OpenCraft, customization is our bread and butter. We eat custom code for breakfast, so this advantage is close to our heart. When you’ve got a dedicated instance, you're in full control of your customizations. If you’re sharing an instance, however, the host has to be very careful about how customizations are done and the dependencies of components, because changes to one site can have repercussions for everyone else. So if you want further customization of optional functionality like XBlocks, ecommerce or single sign-on, you’re going to face some challenges in a shared instance.
This inflexibility carries over even into areas like localization. While it’s possible to install additional languages on a shared instance, it could have technical implications for other sites, especially if you’re dealing with languages such as Arabic or Hebrew that are read from right to left. For us, installing a new language on a dedicated instance is about one hour of work.
Finally, by providing dedicated instances, we’re able to ensure reliability. Maintenance and upgrades are included with all our hosting plans, and we have a track record of exceptional, 99% availability. We also create daily backups for every instance and can restore backups quickly and easily.
So, while it’s a bit more costly for us to provide our clients with dedicated instances, we think it’s worth it in the long run. Stronger security, fast performance, full control, scalability and as much customization as you want —these are important to anyone who’s running an Open edX instance. Besides, if you want to provide a high quality experience, you can’t take half measures.
Want to learn more about our hosting plans? You can check out all the details here. Or get in touch — we’d love to talk with you.
Photo by Paul Gilmore on Unsplash
This article was written by Jeff Miller, a member of the OpenCraft marketing team.
I’m excited to share that we have launched an updated Pro & Teacher hosting plan for your Open edX® instances! We work very closely with our clients, and we listen to their feedback. As such, we have been working hard to improve our hosting plan after hearing that customization was too limited, the process to make changes to a theme was too time consuming, and that the price point was too high.
New features include a dedicated, secure instance that is backed up and monitored by the OpenCraft team, an unlimited number of online courses to serve a wide and diverse range of learners, a new UI console that provides a streamlined user experience (and includes a comprehensive theme editor for complete brand adherence), and the ability to create and support both custom domains and page creation for privacy policies and service level agreements.
With the new self-service platform, you can easily customize your own Open edX instance to provide a smooth registration and onboarding experience, as well as a customized look-and-feel to reflect your brand. You can easily install your instance and access it quickly. There’s no need for extensive technical knowledge or additional consultants. We have also introduced multiple pricing tiers based on the number of active users, which enables you to get all the Open edX platform’s essential features at a much lower cost. The details of the pricing tiers are outlined below.
Here’s a look inside the platform.
A revamped user console features a comprehensive theme editor that allows thorough branding of the instance with options to customize colors, logos, buttons, navigation, footers and hero images.
Configuration options include custom domains:
Additionally, you can create custom pages, such as terms of services or policy privacy pages:
OpenCraft is offering two hosting plans: Pro & Teacher and Institutional. See our website for a full comparison of the plans.
Each plan:
The Pro & Teacher hosting plan provides all the essential features at an entry level price. It’s ideal for smaller organizations, teachers and even people who just want to try out the platform. It starts at just €39 / $43 per month for 50 users.
The Institutional hosting plan is designed for larger organizations with greater needs. If you want to scale up to millions of users, offer services such as e-commerce and mobile apps, receive expanded support and take advantage of OpenCraft’s experts for custom development support and services — then this is the plan for you. You can get a quote and learn more about our Institutional plan here.
Want to try the updated Pro & Teacher plan? Get started with a 30-day free trial here.
This article was written by team member Tim Krones
From fall of 2016 through summer of 2018, OpenCraft worked closely with the edX for Business team and Arbisoft to build out and improve several crucial features for the Open edX Enterprise Service. These features still exist today and are ready for everyone in the Open edX community to use, extend, and build upon. We’ll describe them in more detail below. But first, let’s have a quick look at what Open edX Enterprise Service actually is.
The Open edX Enterprise Service code base adds support for a number of different use cases to Open edX, mostly in the realm of B2B. It is included in standard Open edX installations by default, but nonetheless a lesser known (or at least a less talked-about) component of Open edX.
It integrates with the ecommerce and course-discovery services. In fact, making use of all functionality provided by the Open edX Enterprise Service requires a working setup of ecommerce and course-discovery. The Open edX Enterprise Service code base also enables edX For Business.
In a nutshell, the service enables alternative ways of accessing course content that is hosted on an Open edX instance: It supports LMS integrations with third-party systems such as SAP SuccessFactors, Degreed, and Cornerstone as well as direct integrations via the Open edX Enterprise Service Catalog API. It also allows customers to purchase course seats in bulk so that they can provide course access to their employees via individual-use enrollment codes or direct enrollment for specific courses with discounts/entitlements. Through data pass-back and customer reports, employers can get information about “learner behavior and outcomes,” i.e., information about their employees’ performance in relevant courses.
As mentioned earlier, one of the key features of the Open edX Enterprise Service is support for integrating Open edX with third-party systems. Aside from general improvements to the code enabling these integrations, OpenCraft’s work in this area mainly focused on two systems, namely SAP Success Factors and Degreed.
OpenCraft expanded the existing integration for SAP SuccessFactors, adding features such as:
Our work also included implementing support for situations where specific learners no longer had a valid SuccessFactors account due to leaving the company or organization that had provided them with access to course content hosted on Open edX.
Integration for the Degreed platform did not exist when OpenCraft was first onboarded to the Open edX Enterprise Service project. We built this integration from scratch and applied large-scale refactorings to optimize code reuse between different integrations of third-party systems. Aside from making it easier to implement additional integration channels for third-party services in the future, these refactorings included making data-passback functionality asynchronous by allowing commands for transferring different types of data to run on separate worker threads as Celery tasks.
In addition to integrations utilizing specific third-party services such as SAP SuccessFactors and Degreed, Open edX Enterprise Service supports direct integrations via the service's catalog API. This increases flexibility for Enterprise customers by allowing them to connect their own learning management systems (LMS) to Open edX. However, not everyone wishing to make use of the Open edX Enterprise Service features has the ability to extend and/or modify their chosen LMS to establish an API integration.
To improve the situation for these types of Enterprise customers (i.e., to allow them to access and work with relevant data from the service with minimal upfront effort), functionality for transmitting data in alternative formats was added to the Open edX Enterprise Service. For example, instead of creating their own solution for obtaining reports from the Open edX Enterprise Service Catalog API, Enterprise customers can choose to have the platform send these reports to them in CSV or JSON format. Reporting configurations for individual Enterprise customers can be changed via the Django admin.
An important aspect to consider when integrating with external systems is that learners should be able to explicitly agree to their data being shared between Open edX and those external systems.
The service provides learners with this ability through Data Sharing Consent (DSC) features. For example, one of the early features that OpenCraft implemented was to ask learners to consent to data sharing when attempting to access courses in which they had been manually enrolled by their organization or employer, and to deny access to these courses when consent was declined. Similarly, in the earlier stages of the project we built functionality for requesting data sharing consent from learners when they attempted to redeem a course coupon provided by their organization or employer.
Aside from implementing and refining user experience for different use cases involving the concept of data sharing consent, OpenCraft also helped create a generic consent API and unified data sharing consent database model, which ultimately made it possible to extend DSC functionality to cover programs.
Creating a smooth experience for Enterprise learners also involved making a number of fundamental changes to existing functionality for registering, activating, and logging in to learner accounts on Open edX. Most notably, OpenCraft worked on creating and improving a special landing page for learners coming to the Open edX platform through an Enterprise workflow. This page allows learners to obtain various kinds of information regarding the platform itself, and the course or program in which they are about to enroll.
For example, when a new Enterprise learner creates an account with the platform, the landing page allows them to view the terms of service of the platform without leaving the registration flow. In a sidebar next to the elements of the page that the learner can interact with, the landing page also displays an Enterprise-specific welcome message as well as custom branding for the Enterprise customer that the learner is associated with. This feature is not specific to the registration flow; it is integrated with login and enrollment flows as well. Branding for individual Enterprise customers can be configured via the Django admin.
When the landing page is shown as part of the process for enrolling in a specific course, the Enterprise learner can view extensive information about the course on this page -- again without having to navigate to a different page. This is similar to the kind of information that the Open edX platform displays on the “About” page of a course.
In a later phase of the project, a landing page with similar capabilities was built for the use case of enrolling into programs. In addition to providing relevant information about the program in which the current learner is about to enroll, the Enterprise landing page for programs provides functionality for viewing information about each individual course that belongs to that program.
Another way the Enterprise learners' experience with the Open edX platform was made as smooth as possible was by minimizing the number of steps required to register or log in to the platform and to enroll in a course or program. To this end, OpenCraft built functionality for hiding irrelevant fields from the registration form and for skipping identity provider selection during the login process. OpenCraft improved the workflow for enrolling into courses by adding functionality for dynamically changing behavior based on whether a learner had already joined a given course: If the learner was completely new to the course, they would be taken to the Enterprise landing page. But if they had enrolled in the course previously, the system would take them straight to the course, never showing the landing page.
Lastly, to further simplify registration flows for Enterprise learners, OpenCraft implemented support for live validation of learner inputs on the registration page. This work involved extensive changes to frontend and backend code for user registration, and the results were visible not just to Enterprise learners but also to regular learners signing up for an account on the Open edX platform.
Want to learn more about our contributions to the Open edX Enterprise Service? Drop us a line and let’s chat. We’d love to hear from you.
Header photo by Samson on Unsplash
This post was co-written by Braden MacDonald (CTO at OpenCraft) and Ned Batchelder (Software Architect at edX). This has also been posted by edX on the Open edX blog.
Congratulations to Harvard University’s Faculty of Arts and Sciences and the Amgen Foundation for the launch of LabXchange!
LabXchange is an exciting new science education platform loaded with innovative features and content, and it’s now free and open to the public at LabXchange.org. Users will find a rich and ever-expanding collection of world-class learning assets, including videos, assessments, and simulations. One of the key features of the platform is that users can freely combine assets together to create their own “learning pathways.” These pathways can then be shared, remixed, studied, or assigned to learners.
Two years in the making, the LabXchange platform is powered by Open edX software and integrated with edX.org. This means that users can use a single account to learn on both LabXchange.org and edX.org, and the same LMS technology powers both sites. To make this platform possible, LabXchange has contributed several major new Open edX features such as Blockstore, Content Libraries version 2, a new XBlock Runtime, anonymous access, and a new visual assessment editor.
Both the LabXchange platform and these new Open edX features were primarily developed by OpenCraft, with substantial support from edX. This project has been possible because LabXchange, edX, and OpenCraft worked closely together and collaborated on every stage of the project from initial implementation planning through to development and launch. Even now that the platform is live, development is ongoing and new features are being added every week. If you want to learn more about how LabXchange was developed, we encourage you to attend this year’s Open edX conference in Lisbon in May where you can hear from the people that worked on it.
Here’s an overview of some of the Open edX features that LabXchange is using:
Your edX.org account is also a LabXchange account. Users can sign in to LabXchange in much the same way as instructors can use their Open edX LMS user account to sign in to the edX Analytics Dashboard. This was implemented using the auth-backends plugin, which allows any Django-based application to share user accounts with an Open edX instance.
Each piece of content on the LabXchange site, such as a video or interactive simulation, is an XBlock, just like each component of an edX course. Most of the XBlocks used for LabXchange are identical to the versions used to build courses on edX.org, although many have a stylesheet applied to match the visual style of the LabXchange site. A few unique XBlocks are used for new content types unique to LabXchange, such as case studies or interactive simulations.
Blockstore is the next-generation content storage system for the Open edX platform, designed to replace the previous “modulestore” and “contentstore” systems that store data in MongoDB. Blockstore is versioned, scalable, format-agnostic, and file-based. That means that it provides a consistent foundation layer that can store video assets, XBlock definitions (OLX), metadata/tags, courses, and other things we haven’t yet thought of. Blockstore is designed to be able to hold terabytes of such data without losing performance. It’s also deliberately simple, creating a platform that developers can use to build experimental Open edX features and plugins much more easily than ever before.
Each learning asset (XBlock) on LabXchange is stored in an Open edX content library, using the new “version 2” of the content libraries feature, which is built using a new XBlock runtime and stores content on Blockstore. These new features make it possible for learners to view and learn from assets in a content library directly, without needing to first import the XBlocks into a course. The new XBlock runtime introduces the concept of “Learning Context” to the Open edX platform, where a learning context can be a course, a content library, a LabXchange pathway, a blog post, an admissions test, or any other virtual place where learning can happen.
Using the LabXchange site, educators can search these content libraries to find content and assemble learning assets (XBlocks) into new learning pathways.
LabXchange uses the same “Problem” component that Open edX courses use, but if you view, create, or edit a problem on LabXchange you might find that it looks quite different than you’re used to! LabXchange uses a new visual style for problems designed to simplify both learning and authoring. In particular, the new visual editor allows instructors to author problems without having to write markdown/XML code, using an intuitive authoring UI that was designed by LabXchange and implemented by RacoonGang. The new visual authoring UI will be available to all in a future version of Open edX Studio as an optional alternative to the current editors.
Users can use many features of LabXchange without needing to register an account, including viewing and interacting with learning assets (XBlocks). Up until this point, users could not view interactive Open edX content (such as problem components) without both registering an account and enrolling in a course. Now, the new XBlock runtime has been designed from the start to be able to support so-called “anonymous” (not logged in) users, and allow them to interact with almost any type of XBlock. In the future, course authors who opt-in to this feature will be able to make a portion of their course available for users to sample before they enroll, and provide a more complete preview experience than is possible today.
We’re excited about the technical advances in LabXchange, and about the collaboration that created it. Open source software, and the distributed working groups it enables, will let us continue to develop and extend the Open edX platform as the best online learning environment. We’re looking forward to more innovation in the future!
This article was written by team member Giovanni Cimolin da Silva
Are you looking into new solutions for your next online learning experience and do you want to offer courses on a customizable and expandable platform? Are you having doubts about which platform you should use to host your next training or class? This article will help you find out whether the Open edX platform is the right choice for you.
The Open edX platform is a powerful open source learning management system (LMS) used by organizations from all over the world to host Massive Open Online Courses (MOOCs) as well as smaller classes and training modules.
The edX® organization, a nonprofit founded by Harvard and MIT, designed and released the Open edX platform in 2013 with the goal of making it possible for universities and institutions to deliver high-quality courses to learners everywhere and to compete with the proprietary MOOC platform Coursera.
We will start by highlighting the platform’s great features, but also look at how the Open edX platform might not fit your requirements.
The Open edX platform was built with the learner experience in mind, and focuses on delivering course content in the best possible way. The learning environment provides a pleasant and streamlined learning experience with features that help learners stay engaged and keep track of progress. It also encourages a social learning environment in which learners and instructors can use its tools and features to form a genuine learning community.
Courses can make use of multimedia content, such as videos, animations and simulations to provide a rich learning experience. XBlocks and plugins can be used to introduce new ways of interacting with learners.
Learners can take their courses anywhere by seamlessly switching from the Open edX’s platform site to a mobile app where content can be downloaded and then viewed offline. Progress is always kept in sync and the flexible learning platform allows learners to work through lessons during a trip or commute. Team learning is encouraged through a diverse set of collaboration tools like discussion forums and file sharing.
Instructors can use the instructor dashboard to manage learner enrollment, generate grade reports, adjust grades, and send bulk emails.
The advanced edX Insights analytics platform can be deployed to collect learner analytics and improve the course experience over time. EdX Insights provides data about learner activity, background, and performance throughout the course. It can help instructors monitor learner progress, and validate course design choices. Collected data provides an opportunity to improve courses and learner experience.
The Open edX platform is always evolving and new learning experiences are implemented on every release. The product roadmap includes adaptive learning and AR/VR experiences to be incorporated into the platform.
The Studio authoring tool is used to create and organize courses is an easy and straightforward way. Instructors and course teams can quickly integrate content ranging from videos and documents to a variety of assessment activities such as multiple choice questions, interactive exercises like drag-and-drop problems, polls, vector-drawing problems, and many others.
Studio also has a draft mode that enables instructors to preview a course unit before publishing it to learners.
On the Open edX platform, courses have a well-defined and easy-to-learn structure while Studio has tools to manage course content, schedules and grading. Courses can be edited at any time and new blocks of learning content, from text to XBlocks, can be added.
The platform uses open XML standards (OLX) for import/export of courses and allows the quick transfer of content across platforms.
The Open edX platform has many customization features and was built with expandability in mind, allowing its community to shape learning experiences not originally envisioned by edX itself.
XBlocks are the building blocks of the Open edX platform. They were created to allow completely customized behavior inside the Open edX platform by using an open standard and a well-documented framework to enable providers to develop custom problems and ways to interact. Good examples of the capability of XBlocks are the Drag-and-Drop (see image below) and Problem Builder on which Opencraft has extensively worked on.
The Open edX platform also has a comprehensive theming engine that allows its users to completely customize the experience, from changing colors and fonts to making custom pages. Service providers like us can create and customize your instance to match your brand, color and make any extra customizations.
It’s possible to integrate the platform with other services using the supported REST API’s. Currently, the Open edX platform includes the following APIs: Enrollment API, User API and Data Analytics API. These can be used to integrate the core platform with services like an external marketing website or an analytics dashboard on your management solution.
The Open edX platform also supports SSO providers and has LTI support, allowing integration with other learning solutions.
In addition, the functionality of the entire platform can be expanded with new features implemented through plugins that can be installed on the instance and access the entire codebase, essentially making the entire platform customizable.
The Open edX platform is completely open source and has a thriving community of contributors, including developers, technology partners, research teams, and users. As an open source source solution, the Open edX platform has many advantages, such as:
Here at Opencraft, we strongly believe in open source, and we aim to contribute most of our work to the community as open source software. We want to ensure that our work benefits the community, and even humanity as a whole, as much as it benefits our clients.
The Open edX platform was built with the goal of being fully accessible by everyone, so instructors can reach every learner with their content. Many features are present to enable that, and any new features added to the platform have to comply with the AA level of the WCAG accessibility standards.
Some accessibility examples include the support for adding video transcripts and screen reading tools. EdX also provides an extended guide of best practices to produce accessible course content.
The Open edX platform operates on the user’s web browser and provides an easy yet robust experience to learners and instructors alike. It can be used to create courses for a few learners or be scaled for millions of users.
The platform supports AWS and we have worked to add OpenStack support. Other cloud providers have their own custom distribution of the platform and there’s also a Bitnami distribution that works on all cloud providers.
The Open edX platform is a great platform to use as is, but as with any software, it also has a few caveats to work around. It might not fit your requirements in some cases, so here are a few additional things you should know:
A number of service providers can set up and host the Open edX platform for you. Click this link to see our hosting plans and sign up for a free 30-day trial.
The Open edX platform and many other features that can’t be explored on a single blog post, so follow our blog and head to https://open.edx.org to learn more.
We are the leading Open edX platform development provider since its release in 2013, besides edx.org. We have made more than a thousand contributions to the platform and its plug-in ecosystem on behalf of our clients. Click here to contact us : )
Cover photo by Wes Hicks on Unsplash
This article was originally posted on the Open edX website.
The upcoming Open edX® release contains an exciting, much-requested new feature: Public Course Content. This gives you the option to make either a course outline or course content available to anyone, regardless of whether they have registered for an Open edX platform user account or enrolled in the course!
This was a community initiative, inspired by Stanford’s implementation, sponsored and specified by Cloudera, and developed by OpenCraft in collaboration with the edX® Architecture and Product teams.
You can see this feature in action now on Cloudera OnDemand:
With Public Course Content, you can make your courses visible to potential learners who are either anonymous (unregistered) or registered but not enrolled in that course. You can decide which courses, and which parts of those courses, you want to to make public. For example, you can:
Existing learners can browse your public course to see if they want to enroll. Plus, Google and other search crawlers can index your public courses, so that people who are searching for information about the topics you teach can then find your course through their normal search behaviours. This can increase the visibility of your organization’s courses and boost enrollments for genuinely interested learners.
See Configuring the Open edX Platform » 4.11. Enabling Public Course Content for instructions on how to enable and use this feature in your courses.
There are still some limitations of this feature, and plenty of scope for future contributions.
We’ve listed some of the missing capabilities we want below, and you can help by adding your ideas and use cases and discussions to the Nonregistered course access thread on the edXchange forum. And bug fixes are always welcome!
Currently, anonymous or unenrolled learners are not members of any cohort, and so they only see course blocks which are not assigned to a content group. If you want to restrict public access to selected course blocks, you need create content groups for your private content, and ensure that your enrolled learners are members of a cohort that can see this content group.
This functionality needs a better user experience, and perhaps a reversal in how it works under the hood. For example, we could create a special Public Content Group, and assign public content blocks to that group. This group could have an option that designates whether enrolled learners also have access to content in this group, so that for example, you could display “teaser” content to public learners, and full content to enrolled learners.
Currently only HTML components, Video components, and course handouts have a “public” view. Unenrolled learners will see a message requesting that they sign in/register and enroll to see more complex content types like discussion forums, problem blocks, randomized content blocks, exams, Open Response Assessment, and other XBlocks.
Unenrolled learners will also not see course completion or progress updates as they go through the course, and the platform doesn’t remember where they left off if they leave the course and come back.
We need to figure out how best to display more complex content types to anonymous and unenrolled learners. Should anonymous learners be allowed to post to forums? Should they be able to complete problems and participate in peer reviews? What happens to their scores and grades when they decide to enroll later? You can help by participating in the feature discussions.
You still need an account and an active enrollment to see courses in the iOS and Android apps.
These apps should be enhanced to have an “anonymous” mode, so that registration is not required to view public courses and outlines.
