We aren’t really writing here anymore; see you on the new site!
“overall this is working great and I’m impressed with where we are at this point” – Greg S.
And not to be left behind, support for WooCommerce 3.0 in Bright is also here!
Need to sell or integrate SCORMCloud based SCORM, xAPI, or AICC content with WordPress and the latest [3.0] version of WooCommerce? Bright fits the bill with
* advanced license key management
* purchaser reports
* support for variable products, multi-course bundles, and more!
Get in touch and begin monetizing your courseware today.
All in a days work. Can’t wait to taste this cake ….
Discussing Bright with an active customer that runs thousands of people through their system a month:
The marketing for Bright should definitely include that fact the system does not require an administrator or an owner. I think that’s really unique. It’s very user-centric, not administrator-centric.
– T Dale, Penman Communications
Our philosophy is that the “LMS” piece should be completely invisible to the user, except at specific points as defined in the user requirements. So if you want to show a user’s progress somewhere, then “say that” by embedding a shortcode that shows progress in that spot.
Really the only visible parts of the “LMS” are the places in the tool where it says “Launch” [unless you want it say something else].
In this way, we can call Bright a “declarative LMS” that runs on autopilot.
Overview
Pages that include bright.js can launch courses without contacting the web server that served them. They do this by connecting directly to Bright.
This creates one issue on the browser side, which is that it doesn’t need to be able to connect to Bright to receive the page, but a networking issue between Bright and the page won’t manifest itself until a **user launches a course**.
The net effect of this was users could get a ‘The Bright Server did not respond’ error on course launch, and the vast majority of times, this issue was local the user’s browser our network. They can connect to their web server, but not to Bright.
New in Bright: Browser Health Checking
To make it easier to resolve these issues, new in Bright is Browser Health Checking. When the page loads, the browser will check it’s connectivity to the Bright Server.
Here’s a normal launch button:
In the case that connectivity cannot be established, the course buttons will ‘grey out’:
If the user mouses over the button, they will receive the following tooltip:
Now if the browser, re-establishes connectivity, the launch button(s) will automatically re-enable themselves. Neat!
When we initially created the license key functionality in Bright, invitations received their # of seats available from the product quantity selected in the order checkout.
So what if you wanted to change this after the fact? Example, customer calls, and you want to give them 10 free seats as a giveaway. Problem was, there wasn’t an easy way to modify the # of seats available on the license. This was a pain point and we heard our customers, so we are happy to announce seats can be modified straight from the invitation console. It also means you can assemble a license invitation without the shopping cart! More on that later…..
Read more about it:
https://help.aura-software.com/managing-license-seats-via-the-embedded-admin-console/
Before we began working on Bright, a nifty little adaptable training delivery platform [and frequently used as an LMS], I did a stint as an LMS selection consultant.
Luckily I didn’t know enough to balk when the customer added this:
And that’s what we did.
Two roads diverged in a wood, and I took the one less traveled by, And that has made all the difference. – Frost
As is shown in the documentation of the Bright Invitation Report Template, adding a reporting user for an invitation is as easy as creating a “reporting_users” custom field for the invitation, and adding a list of email addresses.
One issue, though. For some complex invitations, the Embeddable Admin Console gave you a rather unpleasant JSON document to edit:
We are happy to report that via the power of “Patented Tyler magicks” as our engineer described this, complex context documents on Invitations now render as:
Ahhh …. much better.
Direct feedback from our most recent Bright implementation:
When you responded to our RFP, we didn’t understand all the terminology in the response so we hired a consultant to help us pick our vendor.
Her feedback was that your existing customers loved using your service, and that drove our decision.
Tools are nice, but driving for customer satisfaction is what drives us. What does that mean? It changes every day, actually.
We can’t always anticipate the problems and challenges that an individual project or implementation will face. It could be technology, or it could be organizational. But we do know that to serve our customers, we need to produce software that adapts to the problem at hand, and we need a services model that adapts to the customer organization. That’s the Bright Manifesto for Great Customer Satisfaction in a nutshell.
If you are a popup hater, you’ll want to have a look at our new help document on launching course from Bright and SCORM Cloud without the dreaded popups.
https://help.aura-software.com/using-scorm-cloud-without-the-popup-window/
Lot’s of nice fancy recipes in there for presenting a more integrated feel for your courseware and your content delivery site.
From
Hey #DevLearn I'm giving a talk on learning ecosystems at 3:15 in the expo hall @ mgmt exchange stage. Stop by!
— Julian Napolitan (@juliannapolitan) November 16, 2016
Or as we like to say, Enable e-learning where your users ALREADY are….
Why did we build Bright the way we did?
Maybe it’s because people say things like this:
“Do people only ever complain about their learning management system (LMS)? It seems that the excitement and anticipation before the LMS arrives is fan-fared with bold exclamations of its all-encompassing functionality: “It does everything! There is so much content! And it even integrates learning, talent, and performance metrics!” But the technology lands and reality dawns. The fanfares dull to: “No one’s using it, and now it’s become a millstone around my neck.”
Read the full article here, LMS Manages Learners but the Business Needs More
Our only goal is to make that story go away.
Want to hear how we create Learning Management projects people don’t hate? Read about it and then ask us!.
Or checkout what our customers are saying.
Bright is fundamentally different than a traditional LMS. It is our goal to help you escape from the constraints of the shrink-wrapped monoliths; software that makes a lot of assumptions about how you will interact with your learner. Bright is so different that what don’t even consider it an LMS, we consider it an “LMS escape portal”.
For example, with Bright, you can put a list of courses anywhere on your website, adapted to your content strategy, not ours. By default, our embeddable widgets pick up your site’s default CSS, so “branding” is never an issue. Putting a logo image at the top of some brittle SAAS tool is NOT branding 😉
In keeping with this vision of “your model, not ours”, we’ve greatly enhanced the flexibility of the Bright Course Table in the latest version of Bright. We’ve also tried to turn on more of the functionality by default, so we closer align to the most common use cases straight out of the box.
Specifically:
- We now support literally any filtering strategy, such as by course metadata like category. Control exactly what courses you serve, and where, and by what rules.
- By default, the table is now wrapped in an interactive paginated, sortable, and searchable web interface. Awesome is now the default.
- Certificate Linking is now the default. Don’t want certificates? No problem, just disable it.
- Self Registration is now turned on by default. “Managed” learning is overrated. Need to control access? We get it … and turning off self-registration is a snap. Do it different ways on different pages, or for different users, or whatever scheme you can imagine.
All the juicy docs are here on the Aura Documentation site. What good is software if no one can use it?
But hey, why not just grab a demo account and play with it yourself? Hit us up and we’ll get you one in a jiffy!
Once you see how Bright works, you’ll be asking yourself, “why would I do this any other way?!”
Recently, in response to some inquiries from some Financial types, we reached out to a couple of knowledgeable customers [and one partner] asking them:
If you didn’t use Bright, what would you use? Who do you think our competition is?
This is relevant to us as Bright sits firmly in the middle of the Build vs. Buy debate. So, it can be a bit difficult to say who we are actually competing against.
In any event, one of our customers sent us this, which I attach here:
Are we serious about the availability of our service? You bet we are.
Some metrics of how serious we are:
* 87 remote monitors on everything from web server response, disk space, swap space, DNS, job status, you name it.
* As of June 2015, we had 110 automated tests. As of today, the # has topped 260.
How does it manifest itself? Here’s an excerpt of an email I received from a customer who monitors the uptime of all of their cloud vendors.
Why is it title: “you did it again?” It’s not the first time we’ve been measured at 100% available for an entire month. Word in the Aura lab is, “next month, we go for 110% available”.
Our hosting provider recently received several Xen Security Advisories (XSAs) that require them to perform updates to their host servers. In order to apply the updates, these machines which host Bright must be rebooted. The XSAs will be publicly released by the Xen project team on October 29th, therefore they must complete the updates before that date.
These updates are required to protect the security and safe operations of not only our infrastructure, but yours as well. We understand that a disruption with such limited notice is inconvenient, and we hope you understand that these measures are warranted due to the severity of the XSAs.
Please see the maintenance window below. Unfortunately, our hosting provider does not provide us with the ability to change these. The outage can happen anywhere within a 2 hour window, but should last only as long as it takes the machine to reboot; which is approximately 5 minutes.
For Bright North American customers:
9PM Eastern Time, Oct 19th and/or Oct 20th [contact us for the exact date for your service].
For Bright European Customers:
9PM GMT, Oct 20th or Oct 23rd [contact us for the exact date for your service].
Bright is super powerful, really. During a demo last week, our partner/re-seller said “I can do anything I want”. Or something like that.
Only problem [at least from our perspective] is the proliferation of Bright customizations in the wild. This can be a bit stressful when we go to change “Bright core”. How do we keep from breaking all those cool client-side customizations!??!?!
Part of the problem has been the testing architecture of Bright itself. Bright server, tested to the hilt. A continuous integration chassis is testing Bright server up pretty much day and night. If it breaks, it’s because we didn’t write a test. Easy to fix.
Nice, but in the end, Bright is primarily used to serve web pages in “other” web stacks. How do we keep track of all that UI code sitting on top of the Bright API?
As an experiment, I decided to rig up qUnit onto the Bright.js library core. We added a special settings option in the Bright plugin for WordPress:
Set that, and next thing you know, your web pages are running the new Javascript test chassis. One nice thing is if this isn’t set, all the test javascript isn’t loaded. So there’s no performance impact on production sites.
With jstest=true test, here’s an example of the test output.
The best part? Adding tests for client customizations, super easy!
For a Bright customizations plugin, just add something like this:
/* add this to your customizations plugin or anywhere you enqueue your Javascript */
function load_bright_customization_scripts() {
if (bright_testing()) {
wp_enqueue_script('my-custom-testing',
plugins_url('qunit-tests.js', __FILE__),
array('bright'));
}
}
add_action('wp_enqueue_scripts', 'load_bright_customization_scripts');
Now add some tests:
// this is my qunit-tests.js
// In this example, we are hooking to the bright tests hooks both BEFORE and AFTER the bright templates are rendered.
// In this test, we will validate the template rendered, that it has data in it, and the the jQuery data tables loaded
// and is usable.
MyTest = {};
Bright.addHook('before_load_tests', function () {
if (jQuery('.bright-template-my_results_matrix').length > 0) {
MyTest.my_results_matrix = jQuery('.bright-template-my_results_matrix').length;
}
});
Bright.addHook('after_load_tests',function () {
if (MyTest.my_results_matrix)
QUnit.test('my_results_matrix',function(assert) {
assert.equal(jQuery('.bright-template-my_results_matrix').length,MyTest.my_results_matrix,'an equal number of divs before and after render');
assert.equal(jQuery('.my-results-matrix .dataTables_wrapper').length > 0,true,"we find that datatables has loaded");
assert.equal(jQuery('.my-results-matrix .dataTables_wrapper table.my-results-matrix tbody tr').length > 1, true, "more than one row found in the results table");
assert.equal(jQuery('.my-results-matrix .dataTables_wrapper table.my-results-matrix thead span.filter_column input[value="Email"]').length === 1,true,
"A text entry search field is found for the email field");
});
});
UGH CODE!!! Yeah don’t worry about that too much. Translated for humans, we’ve made it very simple to write unit tests for Bright templates. Testing rocks!
Honestly, it’s about time.
Bright documentation website, from Aura Software:
http://help.aura-software.com/
Its a living breathing thing and we update it every day! That being said, Bright has a lot of features and it make take a while to fully flesh it out. Suggestions welcome. For the moment, we are focusing on storefronts and e-commerce integration.
Alternative chains certificate forgery
Earlier this morning, OpenSSL released a security patch to fix a new vulnerability discovered in OpenSSL versions 1.0.2 and 1.0.1. This patch fixes one high severity vulnerability, which primarily affects clients.
- This bug does not affect private keys for Certificates on Bright Servers
- No hardware operated by Aura Software is effected.
- No action is required of Bright customers unless a) you are operating your own hardware; in which case you should check with your hosting provider or b) your site use a certificate not directly procured through us.
Developing e-commerce solutions for SCORMCloud is an emerging business for Aura Software, and we are happy to hear that Rustici Software AKA SCORMCloud will feature Bright in a business case on ecommerce to be published on the scorm.com website. I just have to get around to writing it….
Since we’ve been talking to Rustici about ecommerce a lot, we have had the opportunity to talk to many prospects interested in using the Bright + SCORMCloud + WordPress + WooCommerce system.
One of things that has fallen out of these conversations is the need for license management in Bright, wired straight into the shopping cart.
The idea here is that a customer might want to buy a 1000 seat license in a single transaction, and then distribute the license internally [or externally] to their organization. You also might want to combine licenses for multiple courses into single transaction, and of course, there has to be reporting.
It seems that many learning content producers make these kinds of deals already, in some cases with considerable manual work or one-off coding. This is something that we feel we can make as seamless as regular single-user course buys already are in the Bright WooCommerce Integration Bridge. Coming soon!
How will it work?
The thinking at the moment is that during checkout, a custom checkout field would be provided for the cart:
When this is set, instead of an actual course registration being generated via the completed purchase, a license key will be generated and attached to the user’s order. The license data will be written into the Bright server, storing the associated courses and the # of seats available.
This key can be used in the following fashion:
- A user can attach this key to their user profile, and we will provide extensions that will allow user profile fields to be mapped to license keys.
- Thus, when a license key is added to a user’s profile, an API call will be generated which will associate the user with the license. This call will have the side effect of generating the appropriate registrations for the user.
- By using Bright templates that require an existing course registration, the net effect of this will be to grant access to users who have added the appropriate license keys.
- The Bright API will insure that the seat limits associated with the key is enforced.
This model supports:
- reporting by license key
- multiple license keys per user.
Based on Google analytics:
– the best 4 months in terms of traffic for www.aura-software.com are #4: Feb 2015, #3 Dec 2014, #2 Jan 2015, #1 Mar 2015
– March 2015 ….. our best month ever by a huge margin [30%]!
For occasions where you have rogue courses that don’t update their “passed” status, but you WANT or NEED the course passed in Bright, you can set a custom course property in your Bright metadata:
The field name is “completion_means_success”.
With that set, every time a registration is updated for this course, if the registration is marked ‘complete’, it will be ‘passed’ as well.
Note, this may not fix existing registrations that were updated BEFORE the change. But no worry, our awesome support will fix that for you in a jiffy.
Under the covers, this is a “after_crawl” registration hook compiled into Bright server. There’s LOTS of things you can do with hooks….
Got “custom” work you need to do to your registrations every time they are changed [aka launched]? Ask us, we do that.
In some cases, we see issues with existing registrations where when launched, they produce the following errors in the SCORMCloud player: “please make a selection”. At this point, the course is frozen and the only workaround is to reset the registration.
After several months of debugging and troubleshooting, it seems that the source of the problem is somewhere deep in the bowels of the sequencing features of the SCORMCloud player.
In working with Rustici, it looks like a two phase fix is in the works.
Phase 1 will be a bugfix for the “alwaysFlowToFirstSco” course property [which currently doesn’t work correctly and thus can’t be used to workaround the problem]. As described here [http://rustici-docs.s3.amazonaws.com/engine/2014.1.x/8-packagepropertiesreference.html]:
“If true the SCORM Engine will always load the first SCO in a course upon initial launch regardless of whether sequencing rules dictate this behavior. “
For courses with a single SCO, this will be sufficient to fix the problem. This bugfix is in progress for SCORMCloud [April 2015] so we expect it shortly.
Note this option is default setting.
In phase 2, the sequencing engine will need to be fixed. Release date for that is TBD.
Got questions about SCORMCloud? Ask us.
One of the most common questions we get is, “what does Bright for WordPress do that I can’t do with the SCORMCloud plugin for WordPress?
Invariably the topic of performance comes up. What we say is the performance of the SCORMCloud plugin for WordPress scales according to the # of courses on the page. So it is “linear”. In contrast, Bright performance is flat …. which means more courses doesn’t result in more time.
So today I got a support request from a customer to look at the performance of a page. It seems that they’d embedded 5 courses on the page, but used the SCORMCloud plugin, not bright.
It was taking about 21 seconds for the page to respond:
So I just replaced those embeds with Bright embeds. There’s even a “SCORMCloud classic” embedder template that replicates the look and feel of the SCORMCloud plugin; so you can’t even tell that it was changed.
Then I refreshed the page:
OK even we grant that this call took a bit longer to setup [for DNS lookup]; we killed it. Wait time went from 21.08 seconds to 1.75 seconds.
So with Bright, the page load time is 8% of what it is using the SCORMCloud plugin; or 12x faster. As the SCORMCloud plugin gives linear performance, you can expect it to be 24 times faster for a page w/ 10 courses on it, and so on.
Curious on how to speed up SCORMCloud applications? Ask us …. we do that.
SCORMCloud maintains launch history, but so does Bright.
But they are totally different animals.
In SCORMCloud, launch history is recorded, in Bright launch history is ‘captured’.
HUH WHAT!? Yer talking …… MADNESS!!!!
But all kidding aside, what’s the difference [there are lots of Bright blog posts with this theme]?
- in SCORMCloud, a course has to write its own ‘launch history’ data. So if its a TinCan course, for instance, there’s no launch history. Also for misbehaving courses, you may also get no launch history. In the world of debugging, this can be a big bummer.
- for Bright, we capture the fact a course has been launched before it happens. This means that you get launch history for TinCan and you get it even if the course didn’t load correctly.
That’s what I mean the difference between recorded and captured.
So we does the Bright launch history include? Lots of goodness! Check it out:
Now this is just formatted JSON like is returned from the Bright API:
- id – that’s just an internal reference. Unlikely to be of much use.
- registration_guid – for SCORMCloud, that’s the registration ID. For other types of course providers, the unique ID for that resource.
- course_guid – for SCORMCloud, that’s the course ID. For other types of course providers, the unique ID for that resource.
- learner_id – that’s the user. Hi!
- launch_source – what requested the launch; or the client type.
- http_referer – this is the page we launched off. It’s the where. Click it, it should be live!
- http_user_agent – the holy grail. User agent. YES!
- remote_addr: IP address of where the launch was requested. Also highly useful and also not available from SCORMCloud.
- request_uri: the actual request generated to the Bright server. Just guts.
- created_at: when?
- provider_launch_url: see below
So there’s some REAL magic here in the provider_launch_url. Since we capture this, we now can provide introspection to running courses. If they can grab their own location [via window.location from javascript], they can do their own logging by holding onto the window URL and logging it.
You can then backtrack via Bright to the original learner id and registration ID. Already we’ve built some really amazing tracking with this…. and the possibilities are quite breathtaking.
What’s next? Recording the registration state before and after the launch. That will be too cool and will provide great insight.
http://wpml.org/2015/03/wpml-security-update-bug-and-fix
So, yeah, upgrade WPML.
But beyond that, this post contains an absolutely fascinating comment thread on how one SHOULD and SHOULD NOT detail security exploits when releasing a fix.
For a split second, I was getting the error
“Oops! There was a general error executing method [createInvitationAsync]: Too many bytes in this Domain.”
out of SCORMCloud while creating a registration.
It seems like registration creation was currently not working [although w/ SCORMCloud’s excellent support we fully expect this to be fixed immediately].
But here’s a great and fairly unique chance to test Bright …. with the SCORMCloud backend responding not exactly perfectly at the moment. Reality is, 100% uptime doesn’t exist, anywhere. But when its 99.9999% you don’t get much chance to test you infrastructure when a cooperating service isn’t working……
In virtue of the Bright web service, all pages are functioning normally, which is what I expected.
But since we know we can’t create a reservation, what do I get if I go to launch a course [which will require a new registration]? LET’S BREAK SOME STUFF!
And here’s what I get:
The launch button changes text, with the error:
“There was a general error executing method [createRegistration]: Timed out waiting for operation – failing node: ip-10-2-20-98.ec2.internal/10.2.20.98:11211”
Everything else functions perfectly well. Does this qualify as graceful failure? Beauty is the eye of the beholder…. but it’s not too bad since launch/registration are a fraction of the requests we server.
And look now, SCORMCloud is already fixed!
I can imagine a fancier message along the lines of ; we’re sorry, your request can be fulfilled just this moment. Why not refresh the page and try again?
In every SCORMCloud realm, there’s an internal ‘SCORMCloud’ application.
But if you go to the application listing:
https://cloud.scorm.com/sc/user/Apps
It’s not there!
This is frustrating because you can still interact with it via the API.
Now, you can coerce the application ID out of SCORMCloud by
- upload a dummy course to the internal application.
- then find the course in the library and click on it. It will give a full URL that will include the SCORMCloud application ID!
Now to get the secret key, take the APP ID you found earlier, and build an URL like this:
https://cloud.scorm.com/sc/user/AppsAuth?appId=[MY APP ID]
in the response, you’ll need to view the page source, and then search for “secret=”
This is the secret key of your internal SCORMCloud API! You are ready to rock!
Got questions? Ask us:
there's no alternative to http://t.co/FZOWhBaing when it comes to flexible, agile LMS or better LearnerXperienceSystem
— ▼ Thomas N. Burg (@thobu) March 15, 2015
SCORM Cloud is the gold standard by which all other SCORM content players are judged. Previously known as Test Track, SCORM Cloud is where the e-learning industry turns to solve compatibility issues and has been for over 8 years. It was actually the first LMS certified by ADL for SCORM 2004 3rd edition back in 2007. SCORM Cloud handles over 7 million registrations each year , so they’ve seen pretty much every iteration of SCORM and have built flexibility into the SCORM Cloud player to account for the wide ranges of SCORM interpretations out there. SCORM Cloud has also racked up a few awards and recognition along the way:
- Brandon Hall Awards- 2 Gold medals (2010 and 2013)- as both a stand alone application in 2010 and for the work CA is doing with Cloud in 2013.
- Identified by several eLearning experts as a ‘game changing’ application when it first hit the market in 2009.
- SCORM Engine was awarded a Brandon Hall Gold Medal in 2014 for a collaboration with LifeWay Christian Resources incorporating SCORM, Tin Can, and Video based content for desktop, mobile and offline environments.
Thanks to Tammy Rutherford at Rustici Software for providing the backing data [and text].
In a conventional LMS, you get all of these:
– a learning management platform. Who takes what learning, when, and why.
– a learning UI. This is how your learning is delivered to the user.
But wait, why are these two functions bundled together? This part makes sense from a software construction perspective [we are only writing one piece of software], but for learners, it makes no sense at all. Why would we connect to the system where the learning is managed to receive the learning?
With Bright, we’ve striven from day 1 to decouple management from delivery. Why? Well….
User interaction is a pretty personal thing. Beauty is in the eye of the beholder, and one man’s UI Taj Mahal is another man’s garbage dump.
The problem with typical monolithic LMS software is that it foists its UI conception [or its designer’s conception] onto the learners. If that fits your model, great, if not, too bad.
Even though not everyone gets it, we will always be dedicated to these fundamental notions:
– management and delivery need not happen in the same place.
– UI is a matter of personal taste, and we will always focus on allowing our customers’ complete customizability of their user experience.
Since the world already has 400+ shrink-wrapped ‘all in one’ LMS systems; what would the point be of building #401? Instead, we try to provide something different.
I found this in an email I sent to a prospect, it sums up the philosophy fairly well:
Based on your requirements I thought you could do pretty well with a shrink-wrapped LMS if your requirements don’t change or change much. I think this is where a lot of companies become disenchanted with their LMS platforms, they don’t or can’t be changed as quickly as the encompassing organization is changing.
From my side, at this point I’m not competing on features, I compete on flexibility. I feel like you can always bolt on one missing feature, but you can’t take a fundamentally monolithic or inflexible architecture and fix that in a day, a week, or probably ever.
In Bright for WordPress 5.1, speed junkies get a little boost.
Normally, Bright loads its Javascript files …. whether the page or post ends up using them or not. Well …. Javascript takes time to load, and if there’s no Bright functionality on the page, why load them?
Since WP makes it a bit difficult to load a plugin on a per page basis, we offer the following compromise.
Make a custom field called ‘bright-stop’, and that’s all. Bright will not load on the page. But if you have Bright templates in your header, footer, or sidebar widgets, you probably won’t want this.
Before we got to roll out all the cool features we’ve got in the backs of our heads ….. it seemed that we needed to get hip.
By hip I mean, today, up to date, the latest greatest, get in with the “in” crowd. Stop listening to a walkman, stop wearing bell bottoms, get rid of the mutton chops. Or is it all in vogue again?
So we are proud to report a massive upgrade to the Bright/Aura infrastructure.
– all machines are now 64 bit 100% SSD. There’s nary a disk drive spinning in the house! Those babies smoke!
– 100% Ubuntu 14 LTS on all devices. Haazzzah!
– Postgres 9.3.5+ everywhere. We are REALLY excited to put this baby to work.
– WordPress 4.1 everywhere.
– Rails 4.1.9 [4.2 …. we see you, we want you, but your time hasn’t come yet!]
– Ruby 2.1.5. Yes!
– JQuery 2.1+
I feel so ….. “modern”. Now let’s build some stuff.
Sometimes, you pull a stat and just go “WHAT!?!??!?!”
It seems, that in Dec 2014, some learner somewhere [distance learning, ya know?] launched a course via Bright once every 3 minutes FOR THE WHOLE MONTH.
Not bragging, but I think we did something like < 5 support tickets. OK that's a lie; I am bragging.
Just staring into our launch statistics for the Bright Platform, and Voila!
It seems we are doing something right:
Now this isn’t the number of times people log into a Bright enabled site and launch a course, rather it’s the number of unique associations between launched courses and users. So if the user launches the course a thousand times, its still just counts as one.
2014 is just an estimate. Last year, December of 2013 was our biggest month ever and will probably be again this year…… so this is quite a cautious estimate.
Here’s how we are described in the Trimeritus list of Vendors of Learning Management and E-learning Products.
Aura Bright (Aura Software, LLC) https://www.aura-software.com/. Not a traditional
LMS, it is a highly configurable SCORMCloud based learning platform that embeds
LMS functionality into any application. Has a WordPress plug-in.
What we find interesting in this review is that the word “configurable” …. this is the only place
the term appears in the entire document.
I guess one of these is not like the others……
It’s amazing how much support labor is expended trying to find out what browser (and on what platform) a user is using.
Not to throw IE under the bus, but if the user is using IE6, that’s something the support team will want to know (and soon). Unfortunately, it is also something that doesn’t always surface immediately.
We do see users who, when encountering launch problems, do a little dance. First they try their phone, then their iPad, then their wife’s Android device, then that dusty old laptop in the corner with the annoying fan.
Then comes the report, “it worked once … I think on my wife’s phone”.
What we’ve discovered is that it’s better if the support team “just knows” the user’s user agent without having to ask. Even when they ask, the answer they get might be incorrect.
As such, with a nod of the hat to everyone who does the dirty work of coaching people on how to clear their browser cache, we are happy to add easy to use user agent tracking to bright.
This information is available straight from the Bright API. To use it, you’ll need to know your Bright realm guid and realm secret key. Don’t know yours? Ask us. You also need to know your Bright URL, it looks something like:
https://[bright server]/bright/api/v2
Now you might want to know your learner’s email address. For this example, will use rstallman@prep.ai.mit.edu.
https://[bright server]/bright/api/v2/launch_history.json?realm_guid=[realm-guid]&realm_secret_key=[realm-secret-key]&learner_id=rstallman@prep.ai.mit.edu
You can actually type that into your browser and get this user’s launch history out. Since you are using your secret key, don’t do this on an insecure computer and don’t do it over HTTP (use HTTPS).
Now what you’ll get out is fairly nice ….
Now what you really want is the JSON Formatter for Chrome 😉
If XML is more your speed, try a URL like this:
https://[bright server]/bright/api/v2/launch_history.xml?realm_guid=[realm-guid]&realm_secret_key=[realm-secret-key]&learner_id=rstallman@prep.ai.mit.edu
We’ve recently become aware of workaround for courses with IE10/11 where you touch the course window to move or resize and it locks into a smaller than full screen window.
After some additional testing by dominKnow support, the best options to use for the “launch parameters” will be the settings below. Please change the existing courses to this and then adjust your procedures for adding new courses.
In this Deloitte review on technology trends ….
“there appears to be a perfect storm of conditions that could make massively open online courses (MOOC)s a major factor by 2020.”
The section title is even “Massively Open Online Courses: not disruptive yet, but the future looks bright.” They said it, not us.
In the Aura lab we’ve been toying with visualizations; and this was just a little proof of concept we whipped up for a customer.
Each spoke of this wheel is a course, and the colors correlates to categories defined in the Bright metadata. Then the length of the bar is number of times the course has been completed, with the title around the outer edge.
Bright, you are about one year old.
How far have you gotten in a year?
– 5255 users registered.
– 349 course modules served
– 11720 individual trainings delivered.
After a long amount of foot dragging …. Bright now polls and stores xAPI/TinCan Statements. What is in all of this data? That remains to be seen; but for the moment, at least there’s a somewhat consistent structure to it.
In the past, we’d have to go spelunking into a course production tool’s activity storage format, which usually turned into some sort of bizarro XML-parsing exercise.
The first step of what is sure to be a long adventure.
Some brilliance going on here:
http://www.jasondavies.com/wordcloud/#http%3A%2F%2Fwww.aura-software.com%2Fblog
I fed it our blog and look what popped out:
Bad blogger; I’ve been distracted and not doing my blog-job!
So much has happened with Bright we barely have time to tell anyone about it.
So here’s something new, its the Bright API Doc-ed via github!
About Aura
A W E S O M E !!!! aaah, what a joy to work with professionals like you 🙂
– sebscm
Bright versus existing LMS
I love it and think it is a massive improvement! Much cleaner and streamlined that the current version of AA and CA.
– klee
Custom E-Learning Site Build
looks awesome! I like the functionality – simple but powerful. Thanks again, the site is awesome – really appreciate all your work on this!
– eks
Per the Dan Marsden blog:
I spent a lot of time discussing the opportunity to run a crowd-funded project to complete SCORM 2004 in Moodle but it’s hard to define a fixed figure that would allow us to complete the project and I wonder if such a large amount of my time could be spent on projects that are more current.
Full support for SCORM 2004 is already available in Moodle by using the Rustici SCORM cloud plugin for Moodle and I think it is more cost-effective to purchase a subscription to their hosted solution which is much more stable/reliable and feature rich than what we could provide directly in Moodle anyway.
Looking to buy or rent an LMS? Could a Bright-based WordPress system fit the bill?
To understand this, it first helps to understand, “What is WordPress?”:
What is WordPress?
For businesses, WordPress is an extremely vertatile technology that helps them maintain content, engage in social media, perform well in search engines and minimize out of house costs.
How popular is it?
Wordpress Usage in the top one millions sites: Source builtwith.com
As can be seen above, WordPress is the top CMS platform used on the internet today. It does comprise more websites than every other CMS platform combined.
In many ways the popularity of WordPress can be attributed to :
- The flexibility of the platform is renowned.
- Nearly 25000 available plugins, the vast majority free.
- 1000s of available themes.
How can WordPress be used as a learning site?
scorm.com has produced a nice case study on how WordPress can be used effectively as an alternative to commercial LMS systems.
How do I do it?
Some assembly required
The degree of flexibility of the WordPress platform, plus the vast array of free plugins for the platforms, means the acquisition process of a WordPress learning site is slightly different than the procurement process for a shrink wrapped LMS solution.
The question shifts from “does this LMS support this feature?” to “how easily will our WordPress-based learning site support this feature?” The vast number of sites that run WordPress insures that in most cases, whatever you want to do with your WordPress site, somebody somewhere has already done it. Flexible authentication, social media integration, shopping carts, event management, polling, sharing, chat, you name it.
The Cream Rises to the Top
Since most WordPress features “snap-in” via plugins, you will find that competition between competing implementations of certain features mean that in many cases, there are several alternatives available to deliver a particular feature.
More choice tends to infuse a drive for quality as competing plugin developers compete to be the leader in their respective spaces.
The End Result
Constructing a learning site based on WordPress, is about acquiring highly flexible, customizable, and low cost infrastructure that can grow as you grow.
One of the trends we see in LMS acquisition that if you survey all the stakeholders and ask “what features must our LMS have?”, you can end up with a pretty long list.
But after going through the time and expense to acquire an LMS system, you may find that in practice you don’t use or need all of the features that you spent your time and money acquiring. In some cases this feature creep is driven not by an immediate need, but a sense that “if we don’t get it now, we won’t get later”. In the world of vendor lock-in, this is a real concern.
Building a WordPress-based learning system is different. The easy to integrate environment and proliferation of plugins and expertise for the WordPress platform means even if you don’t get it now, you can have it later (if you want it).
For some organizations, it is liberating to move to from “what features do we need anytime, forever” to “what do we need today?” And for many, that means less time and less money.
How can Bright help?
Bright is an innovative platform for integrating trackable e-learning into web construction platforms like WordPress.
Bright enables many functions that are typically found in a commercial LMS system to be integrated and embedded in a WordPress site. And Aura can provide the expertise to move you from your requirements document to a functioning learning site in short order.
Find out more about Bright here.
Bright
Find out more about Bright
Find out more about Bright
One of our customers noticed yesterday that the Rustici SCORMCloud plugin would “auto-tag” your courses, based on your WordPress post or page categories.
For the purposes of backward compatibility, we’ve picked up similar functionality.
For Bright, its set in the shortcode though:
All is right in the world.
Check SCORMCloud, the post categories are there as course tags:
ALL IS RIGHT IN THE WORLD!
Here’s a short video describing how to configure a Bright embed code or widget to dynamically refresh itself after a certain interval.
Template for Random Course
Here’s the template code from the demo, created via the Bright Template Editor from the WordPress administrators console:
Embedder Shortcode From Video
[bright template=”random course” type=”courselist” refresh=”1000″ class=”none”]
[/bright]
Sounds easy right?
Not so fast!
The state of the state is that how exactly to do this is yet to be defined.
This means for TinCan adopters, our recommendation is to hold fire for the moment.
See also:
https://github.com/adlnet/xAPI-Spec/issues/170
If you read through this thread, you can see its pretty much TBD at this point although Rustici does have a recommendation.
Also:
https://github.com/adlnet/CMI-5_Spec_Current/blob/master/cmi5_runtime.md#content_launch
https://github.com/RusticiSoftware/launch/blob/master/lms_lrs.md
I was asked an intriguing question during a meeting yesterday:
Can you send us 5 or 10 sites that you like, just to inspire us? You can include a basketball site! (I’d already revealed my basketball obsession).
Interesting question and a bit of a challenge.
So here’s what I’ve got.
http://medonline.at – This is a case study (from my perspective) on how to integrate trackable e-learning into “something else”. Learners take courses and interact with the modern, non-tracked content “all in the same place”. Yes they are an Aura customer.
Google Circa 1999
https://www.google.com/ – always a classic. I prefer the circa 1999 or 2000 edition:
http://web.archive.org/web/20000229040250/http://www.google.com/
Clean and simple. I still think this is my all time favorite web page. It came at a time when people were trying to jam as much as possible onto their page, refreshing to see something going the other way. Compare to yahoo! from the same period:
http://web.archive.org/web/20001207164500/http://www9.yahoo.com/
Basketball Reference
This is a great basketball website: http://www.basketball-reference.com/
Again, I love the “clean” approach. Some nice programming went into it. Surf around and a certain elegance will manifest itself.
Bright Product Page
My new favorite web page: https://www.aura-software.com/software/bright/
OK … that’s my web page. But I still like it. I used gliffy to create the top image (gliffy.com) and we used the WordPress shortcode API (http://codex.wordpress.org/Shortcode_API) to make generating the “image/text” blocks a snap. This is something that is extremely powerful in WordPress that can make it easy for non technical user to generate beautiful web pages.
The shortcode API came in very handy when building the Bright plugin for WordPress; too bad Drupal doesn’t have the same.
http://flipboard.com/ – for mobile devices only. Flipboard is game changer for delivering content. Time included Flipboard in its list of “The 50 Best Inventions of 2010” and Apple named Flipboard “iPad App of the Year.”
Wired Magazine
http://www.wired.com/ – Wired has really pioneered the unification of print and digital edition magazine publishing. I was a print subscriber, and they moved me to a digital subscriber. Since the New Yorker has adopted the same platform, I am now a New Yorker subscriber (after letting my print subscription lapse after many years because it was just too much paper). (http://www.newyorker.com/). If I am on a desert island and I can only receive one magazine, can it be anything but the New Yorker?
538 Blog
http://fivethirtyeight.blogs.nytimes.com/ – Greatest political blog of all time? I think Nate Silver has to be put into the blogging hall of fame. For the 2012 election, his blog was the silver bullet into the heart of the conservative echo chamber bugbear.
Generally speaking, other than their terrible attempts at paywall implementation, the New York Times has done a good job of integrating modern web technology without losing the “old school” feel that is part of the NYTimes brand.
Back before TinCan, you could make a SCORMCloud API call like this:
http://cloud.scorm.com/api?method=rustici.registration.getLaunchHistory &appid=myappid®id=myreg001
and you get a nice XML document like this:
<launchhistory regid="e222daf6-6005-4344-a07e-0aaa46b21dc9">
<launch id="c7f31a43-706a-4f43-8ab9-ebbf0dde4cbc">
<completion>complete</completion>
<satisfaction>failed</satisfaction>
<measure_status>1</measure_status>
<normalized_measure>0.2</normalized_measure>
<experienced_duration_tracked>2628</experienced_duration_tracked>
<launch_time>2011-04-05T19:06:37.780+0000</launch_time>
<exit_time>2011-04-05T19:07:06.616+0000</exit_time>
<update_dt>2011-04-05T19:07:06.616+0000</update_dt>
</launch>
<launch id="fc80087b-0fde-4263-8a89-29bee96eb65a">
<completion>unknown</completion>
<satisfaction>unknown</satisfaction>
<measure_status>0</measure_status>
<normalized_measure>0.0</normalized_measure>
<experienced_duration_tracked>2628</experienced_duration_tracked>
<launch_time>2011-04-05T19:15:51.177+0000</launch_time>
<exit_time>2011-04-05T19:15:59.450+0000</exit_time>
<update_dt>2011-04-05T19:15:59.450+0000</update_dt>
</launch>
<launch id="ffd2d304-439c-4c59-8be8-5d3fc1eb3f92">
<completion>complete</completion>
<satisfaction>failed</satisfaction>
<measure_status>1</measure_status>
<normalized_measure>0.27</normalized_measure>
<experienced_duration_tracked>10223</experienced_duration_tracked>
<launch_time>2011-04-05T19:16:07.214+0000</launch_time>
<exit_time>2011-04-05T19:17:25.294+0000</exit_time>
<update_dt>2011-04-05T19:17:25.294+0000</update_dt>
</launch>
</launchhistory>
If you been loading TinCan courses into SCORMCloud, you may have noticed that you no longer get any data from this!!!!
For example, we now just get this:
"<?xml version='1.0' encoding='UTF-8'?>\n<rsp stat='ok'><launchhistory regid='DiabetischeNeuropathied648d063-05b7-43e3-8b67-57568e329f4a-f59356563f5fd7e6104fe03d870c5007' /></rsp>"
So what’s the story? A lurking TinCan-ism that doesn’t match to SCORM? Probably.
So here’s the response from support.scorm.com ….
The Launch history, as it lives today, is focused around the SCORM API calls that are made by the content. Because the SCORM API is part of the SCORM player we have an opportunity to record those calls at the time they happen and format them into a readable log. For TinCan there is no player. This is a boon for content creators because it gives them far more freedom with their content than SCORM did but it has some limitations.
Those limitations all exist around the lack of a player for tinCan content. TinCan content exists in the browser outside of a player and sends statements back to some endpoint via existing http protocols which can’t be intercepted.
What this means is that you have two “views” of what might be considered launch history:
1) Statement Viewer – Statement viewer can show you all of the statements related to a registration. This represents all of the communication between the content and the ScormEngine that was *saved*. The only exception for this would be the state (replacement of suspend data) data which we only save the most recent value and don’t display in the statement viewer.
2) Browser Debug tools – Obviously these tools are only going to be useful when you’re testing a course live but they will provide more information than the statement viewer. Because all communication in TinCan will be handles by simple HTTP POSTS, PUTS and GETS you should be able to see all the successful and unsuccessful API calls including Statements and State.
This sort of illustrates what I’ve been saying to a few customers. If you don’t have a good reason to publish your course packages in TinCan format, SCORM packages will be a smoother landing, at least for the time being. There are a few reason for this….
Poor SCORM. Its a bit of an elearning standards whipping boy, but the reality is it works (mostly).
I say mostly because if you have a dodgy network connection, it might not work too well actually.
We have a prospect for Bright who is looking to “syndicate” their content and this is an interesting use case for Bright and we do this quite well.
But while I was discussing it with them, I got to say something really nice about SCORM that I want to share:
“So I’d say if you want a semi-easy path to content syndication, SCORM packages are actually a good solution (I finally got to say something good about SCORM), because it completely encapsulates the course and it can now be dropped into any SCORM compliant container.”
Thank you SCORM!
-bret
Its nice when other people recognize what you do…
I had a chance to ask a potential customer who came knocking at our door how he heard about us?
“Oh you guys are listed here!”:
SCORM Cloud plugin for WordPress on scorm.com.
That’s nice, what did they say?
“These partners have done great work with the SCORM Cloud plugin and may be helpful for you:
Aura Software”
Why thank you! And that was BEFORE we built Bright. 🙂
We are super excited about selling our 4th Bright Enterprise license (since we launched in June).
What are the main compelling points of Bright:
– on the publishing side, the near limitless flexibility of WordPress.
– on the server side, essential LMS functions available via Web Service API. Push our buttons!
– a data integration framework to move your data where it belongs; not trapped in our silo.
– people, always the biggest factor in success.
Right now people are pretty much coming to us, but I’m imaging Bright with a single salesperson and the possibilities of that!
Our customers are always asking us, “what content authoring tool should I use?”.
First, I have to recuse myself because I am a collaboration fanboy. I love sharing documents on Google Docs for instance, and I absolutely detest emailing MS Office documents around. “Where’s the latest version?” Anytime anyone asks this question, for me its like fingernails on the chalkboard. STOP!
So that being said, I think this is actually a pretty easy call to make.
Do you want to collaborate on your courseware? Do you have multiple people you want to be involved in the production process? Content experts, designers, digital producers? Then a collaboration oriented tool will be music to your ears.
Are you a one person wrecking crew who plans on doing it all yourself? Then the overhead of using a collaboration tool will just drive you nuts. Want to work on your project in the Gobi Desert? Forget it.
Now for us, we use a team approach for content production, so we have to have a collaboration tool. Where’s the latest version? Where it always is, of course.
-bret
The nice people over at the eLearning Guild asked us to contribute some tips for their ebook:
“53 Tips on Using the Cloud for eLearning”
Here’s some of our quotables:
ELearning systems are useless if there’s no content to put in them. Develop your con- tent strategy first, and then decide where to host it.
To those who regularly use cloud-based services, it’s quite familiar to use online provid- ers for tooling around business functions like training and competency development. But some IT departments, and potentially other parts of your organization, may oppose these initiatives for a variety of reasons. Be prepared for some internal IT politics. You may encounter resistance because your solution is “different,” “scary,” or because it shifts jobs out of the company. If you have incumbent systems, your cloud-based initia- tive is sure to kick up some dust.
Launch a pilot before you get in too deep on a cloud-based system. Generally this involves creating an internal working group assigned to use the system for a month or two and give feedback. Of course, this only works if the working group is actually working. That said, if you have disgruntled users by the end of the pilot, you are prob- ably digging in the wrong place.
Although it’s not exclusive to the cloud, maintaining your user lists in an eLearning sys- tem can be quite a chore. Therefore, the functionality provided around maintaining and segmenting your users will become very dear to you, so try to find a system with pow- erful management features in this area. Ultimately you may want to just “sync” your master user list into your learning system, which means adding users who don’t exist and deactivating users who have left the organization. Sounds easy, but it can be quite complex in practice.
While your new cloud-based eLearning system may have some compelling features, remem- ber that if you decide to switch vendors later, extensive use of those features may lock you in to a place you no longer want to be. Using a transportable content format like SCORM helps en- sure that you can at least migrate your content should you decide to move along.
Putting your eLearning in the cloud means some of your content and data now resides in systems you don’t completely control. The best thing you can do to protect yourself is to identify and implement basic security procedures. Simple things like using hard-to- guess passwords and deactivating unused accounts can go a long way. Have a secu- rity review before you launch.
We’ve had people banging on the door for a few weeks asking to see Bright Network and so it was nice to finally get our milestone completed and put it out there for people to see.
You can check it out here, but it’s probably best to contact us for a demo (we love to hear from people).
Only problem is, behind the first milestone is milestone 2, then 3, then 4… well, I guess it’s nice to know what you’re doing with your year 😉
Completed some additions to the Aura Bright theme today so that now you can have light-coloured backgrounds, and the panels display still looks good.
One side-effect I noticed while doing this was that the iPad corrupts a fixed background when being turned from landscape to portrait. I’m pretty sure this is a problem in the browser, which is quite annoying.
Luckily, with the right background image, this wasn’t a problem for our clients, although I wonder if we’re going to see this issue again sometime.
Things don’t change so quickly in the world of e-learning, but Rustici are starting to really set the pace with Project TinCan.
We’ve mentioned DominKnow in other pages on this website, and for good reason: they build a quality e-learning authoring tool called Claro. We love this tool, and get a lot of value out of it: and so do our customers.
One thing that is really mixing things up in the e-learning world right now is mobile… and specifically, iPad. || Read more
Rustici (of ScormCloud fame) are pretty keen on what we’ve been doing with their platform, so they invited Bret along to DevLearn to talk about what Aura have been up to. Here are some shots of Bret giving the presentation.
Bret was talking to the assembled masses about how the Bright platform brings together WordPress, ScormCloud and analytics – and how that was enabling one of our Fortune 500 clients to completely crush it with their sales training solution.
What is SCORM?
SCORM is a standard for publishing learning content. Put simply, the idea of the SCORM standard was that it was a way of allowing learning content from any given provider to be put into a compatible LMS, so that if you purchased an LMS for your IT department, you were not tied into the courses provided by the LMS vendor, and you could add SCORM compatible courses from anywhere. || Read more
Aura has been invited to provide material for the ELearning Guild‘s new eBook:
50 Tips for Using “The Cloud” for eLearning.
Look for it this summer!
Aura has been asked to present at the Geneva Entrepeneurs, “Recession Beaters”.
Here’s the blurb from their mailer: || Read more
Some organizations find their requirements don’t match the functions delivered by traditional learning management systems (LMSs). These organizations need significantly more flexibility and more control over the learner experience. In many ways, these organizations want a custom learning website where the trackable learning content (such as SCORM packages) is just a component of something else. || Read more
See us in the e-learning guild’s “Using “The Cloud” for eLearning” online forum, June 7-8th.
“Aura Software combines technical expertise and a deep understanding of eLearning to deliver unique and effective learning solutions. They excel at using the latest technology, including cloud based technology, to build training platforms that address current requirements and room to meet future challenges.”
Aura Software LLC specializes in the agile construction of solid enterprise-class back-end solutions, using technology that is fully complementary to ASAP’s user-experience-centric solutions. When it comes to complex back-end data management and processing, I trust them like no one else to ensure a successful outcome. This is not just talk, but is borne out by many years of collaboration. Among their many services, Aura performs enterprise data analysis, migration, management, business intelligence tools, content managed site construction, business technology consulting and advice, and customized learning management solutions and content.
