forkingeducation

forkingeducation

A blog about Open Source, my work at the Gates Foundation and those I am fortunate enough to collaborate with

You can scroll the shelf using and keys

Learning Maps – A new UX for Personalized Learning

August 4, 2011

One of my princpal projects is a collaboration with Brandt Redd, Danny Hillis and Danny’s incredible team at Applied Minds.  We’re calling it the “learning map”, a navigational tool for knowledge that learners would be able use to orient themselves to a particular subject and track their progress in it.  Coupled with a datastore and links to content respositories capable of serving up interventions in context, the map would be able to sustain both rudimentary learning pathways but also more advanced functions and services such as predictive analytics and recommendation engines.
The basic idea is that the Learning Map sits at the nexus of information about me as a learner, the content I am consuming, and the diagnostics I am taking to determine my level of understanding of the concepts I am expected to master.  Here’s a graphic that I hope will help you picture what I am describing.

There are 7 core use cases that we believe such a map can help us address:

  1. Teachers can plot their students’ locations on the map, see the resources available for them to use in class, and determine
    appropriate interventions to help the kids progress
  2. Learners can plot themselves on the map,understand what lies ahead, see the resources available to them in their
    current location, and plan their own progressions.  Ultimately skin their own maps, plot their own quests and share them with friends
  3. School and District leaders can plot student movement on the map and get a snapshot and trend projection of a body of
    learners, including what resources are being used by the learner population (and which are not)
  4. Curriculum developers and content producers can publish and locate their courses and resources in the map for discovery and use
  5. Application developers can publish and attach their applications to specific points on the map
  6. Investors can see resources currently available in the market and a status of their use (think a resource heatmap for devs and investors)
  7. Data miners and diagnostic service providers can write adaptive algorithms against the map that allow machine based diagnostics, predictive analytics and recommendation engines for learner interventions (think Bayesnet enablement  similar to predictive traffic flow in GPS)

All one requries to get started is a set of learning objectives in a machine-readable format.  The author of those objectives would also have the option at publication of describing the relationship between them thereby enabling a rendering of the progression from topic to topic.  This is but an initial assertion.  Evidential probability analysis would help true learning pathways and relationships between objectives emerge over time as more and more people lay down paths through the subject area.  If one wanted to get truly funky, one could leverage an arcane markup like PROWL to weight the relationships between objectives allowing for further differentiation and customization to an individual’s learning patterns.

So what might the rest of the recipe for a learning map look like?  Here’s my guestimate:

  1. A marked up set of learning objectives, such as the new Common Core standards for math and literacy.  XML, OWL or (PR)OWL are all viable as would RDFa if one wanted to roll like that
  2. A semantic schema to describe key structural elements that make up the standards and, by extension, the map, e.g. Domain, cluster, concept
  3. A machine-readable tagging of each structural element within the map.  Something like URI.  This would permit linking of data to data, and node to content resources and applications
  4. A way to describe demonstrations and activities required to progress along the standards, e.g. ‘Skill’, ‘Task’
  5. An API to bind the map to either a native or web-based UI, a datastore (ideally a large-scale tuplestore like Freebase) and various content registries such as Steve Midgley’s exciting Learning Registry project

Coupled with these basic ingredients we would also require some transactional web service capabilities to support the feedback loops and uses I listed earlier.  In rough increasing order of complexity those would include:

  • Some form of asynchronous or duplex communication between a datastore and the map so learners show up in
    their appropriate locations
  • A way for URI’d nodes in the map to link to URI’d resources located on 3rd party servers, like Google Scholar or Wiki (this is where the Learning Registry might hook in in a powerful way)
  • A way to broker services between nodes and resource repositories
  • A way to build probabilistic analytical engines underneath the map capable of leveraging the map’s tuplestore to plot, diagnose and serve up recommended learner progressions based on their particular performance and consumption patterns across a range of individual and collaborative activities.  Vivienne Ming and her team at SOCOS are an exciting example of the sort of services we’d like to see emerge in this space

So what might one of these maps actually look like.  Figure 2 below shows an example.  It was created by Larry Berger and Laurence Holt of Wireless Generation and provides an exciting sample visualization of a learning map for the Common Core Math Standards that could be built using the basic ingredients described above.  Larry and Laurence write: “Known as “the honeycomb,” this application would be interactive and display a student’s progress through the standards.  Each hexagon represents a single skill or concept, and groups of hexagons reflect the clusters of skills and concepts that together make up a standard. Drawing on the data infrastructure of the SLI, such a map could track a student’s progress, with cells turning from red to yellow to green as he mastered components of the standards. The slider on the left side of the screen would allow the student or his teacher to zoom in on the cells, which would display more granular information and links to aligned content and diagnostic assessments to help the student continue to move ahead. Individual student maps could roll up to classroom maps, classrooms could be aggregated to school maps and so on, up to the district and state levels.”

Figure 2: Visualization of the Common Core Learning Map

I am interpreting Larry and Laurence to be describing a visualization of raw XML in a native app or downloadable client.  It would not be hard to add to their list of features the URI links and a way to express sequencing between the hexagons.  One could imagine a service event being triggered either by onMouseover or when a student actually “shows up” in that hexagon, i.e. data informs the map of the student’s new location.  The one tricky part would be brokering the link between a URI describing a hexagon in the visualization from the app, over a firewall, through a service broker, through a proxy or two, over another firewall and into a publisher’s digital content server where a relevant resource is then retrieved.  Steve Midgely and his team are on of the groups working to tackle that problem, which is great, because its really tricky and Steve is really smart.

The visualization is exciting for the possibilities it represents and its intuitive UI.  However it is also limited by its medium.  For example, there is no reason why the same functionality described in the visualization could not also be accomplished using a combination of the APIs contained in the new HTML5, along with the design advances in CSS3 and performance gains we’re
seeing from a Java framwork like JQuery or Python.  Such an approach would also have advantages and afford additional options over a more traditional app approach, namely:

  1. Scalable Vector Graphics – no pixilation and therefore no detriment across device form factors. Key for mobile scenarios
  2. Capability of creating multiple visualizations (trees, roads, mazes) that leverage CSS classes and elements
  3. Ability to render those visualizations in zoom-able 2d or manipulable 3d using the SVG and webgl capabilities
  4. Ability for users to take the maps offline using a combination of the new App and Data Caches found in HTML 5
  5. Ability to run browser intensive background scripts using the Worker API in order to facilitate more advanced query, and
    script-intensive mapping or diagnostic services
  6. Ability to use the web socket API to set up full duplex connection between a back-end db, web or app server and the UI
    effectively conferring first-class status on the map and avoiding latency drivers like long-polling, and roundtrips, or the need for the client to initiate communications
  7. No procurement process to navigate, no sysadmin installation required

Based on my early inspection of HTML5 and its API set I believe we can build an open and extensible Learning Map Web app, and that it would be the sort of project that would lend itself well to the Open Community to sustain.  However, we would still need some solution to the earlier list of system capabilities required to support such an app, namely: integration with a student datastore so learners can be mapped; a way to link URIs across servers; a way to broker services between URIs; and finally, a way to build engines underneath the map capable of supporting adaptive tutoring and diagnostics.

Of these issues, the first could be dealt with by some form of federated datastore .  The last will be dealt with using a combination of datamining, Bayesian analytics and scalable machine learning algorithms like Apache Mahout, or with integrated approaches from commercial providers like SAS or IBM which can now couple Watson’s capabilities to its recently acquired SPSS program.

So that leaves URI linking and transaction services. To solve that problem one could take advantage of Steve’s Registry and its elegant NNTP-like approach.  Here’s an illustration of the Registry’s Transport Network:

There are some questions we need to answer before going with an HTML/script-based approach to produce an actual navigable map:

  • Validation of the assumptions I listed in this posting
  • A sense for when all top 7 browsers will support those assumptions on both desktop and mobile
  • A view on backward compatibility and what our fall-back option is for older browsers (almost certainly an app)
  • A better sense of dev resource requirements we would be incurring
  • The authoring tool required to edit or create new visualizations (more on that in a future post)
  • A way to express relations between concept nodes or clusters, some of them multivariate

I hope this paper has been easy to follow and I would greatly appreciate hearing your reaction to it.

Advertisements

What do you think?

Please keep your comments polite and on-topic.

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: