grapple tutorial paul de bra eindhoven university of technology with contributions from the entire...

GRAPPLE Tutorial

Paul De BraEindhoven University of Technology

with contributions from the entire GRAPPLE team

September 30, 2009GRAPPLE Tutorial

Slide 1

What is GRAPPLE?

• EU FP7 STREP Project– 15 partners from 9 countries– 12 education/research, 3 companies– budget 5.3 M€, subsidy 3.85 M€– 3 year project, currently “half way”– main goal: delivering an integration

between Learning Management Systems and Adaptive Learning Environments


Slide 2


Slide 3

GRAPPLE Consortium

adaptive e-learninguser modeling architectures

authoringmetadata

industrial learning technology

interfaces /server technology

open source learning management

interaction

standardslearning design

TU/e

TCD

IMC

ATOS

GILABS

OUNL

USI

TUDelft

L3S

UCAMUCL

DFKI

Warwick

VUB

evaluationUniGraz

GRAPPLE Plans in Detail• Provide a generic adaptive TEL solution that:

– works with many different LMSs– has rich authoring tools (independent of LMS)– includes a modular, extensible, general-purpose

adaptive learning environment– connects everything through a common event

bus and user model framework

• Provide documentation and training– evaluation through experience of GRAPPLE in

actual use


Slide 4


Slide 5

Simplistic Architecture View

Adaptive Learning Environment

Service oriented

framework

Manage userManage enrollments into coursesAdministrative workflow managementDelivery of learning materialsAssessment and evaluationsPortfolio management

Single Sign On facility (SSO)Providing communication channelsUser modeling facilitiesUser Profile exchange facilities Adaptation of page content on User Profile

•(fore)knowledge•prerequisites•preferences

Adaptation of page content on deviceAdaptation of testing toolsCollaborative filtering of resourcesAdaptive guidance

GRAPPLE Components

• GRAPPLE Adaptive Learning Environment– Core engine able to provide to the learner adaptive

courses: the adaptation is based on the foreknowledge, course prerequisites, user’s preferences and device used.

– Can be used stand-alone or in combination with other GRAPPLE components.

• GRAPPLE User Model Framework– In charge of managing, storing and providing all the

shared User Model information. Core user model ontology, conflicting information reconciliation, issues of privacy and trust, user model representation to allow student to reflect on their own knowledge.


Slide 6

GRAPPLE Components (cont.)

• GRAPPLE Authoring Tool– Used by the authors and instructional designers to

create an adaptive course (based on the user profile):• DM: Domain model, authoring VR Learning Materials and

Adaptive Simulations.• CRT : Conceptual Relation Types• CAM : Conceptual Adaptation Model

• GRAPPLE Event Bus– Used by all components to communicate with each

other:• Pull: one component querying another components• Push: broadcast updates to all interested parties


Slide 7

GRAPPLE Components (cont.)

• Learning Management Systems:– extended to communicate user model data– configured to use single sign-on with other GRAPPLE

components

• GRAPPLE VISualization– Available to learners, tutors and teachers to monitor the

progress of the class(es) or of the single learner.

• GRAPPE Additional Components– Virtual Reality extensions: authoring and adaptation of VR

learning material– Simulations: authoring and adaptation of simulated dialogs


Slide 8

The GRAPPLE Infrastructure


Slide 9

Tutorial Parts/Topics

• Creating conceptual adaptation models– using authoring tools– understanding prerequisites

• Creating content (pages) for GALE– using templates and layout definitions– user model operations within pages

• Setting up the GRAPPLE infrastructure– combining an LMS with GALE– exchanging user model information


Slide 10

User-Adaptive Systems


Slide 11

The GRAPPLE Domain Model

• An application consists of concepts and relationships.– The structure of a DM resembles an ontology.– DM is stored using IMS VDEX.– Each concept has properties and resources.

• title, description, …

– Relationships are binary and have a type.• typeOf, belongsTo, which can be application-independent• isPlanetOf, isMoonOf, which are application-dependent


Slide 12

Example

• “Milkyway” running example

• We see the concepts and relationships

• Properties are not shown here

April 21, 2023GRAPPLE Tutorial

Slide 13

The GRAPPLE User Model

• The User Model is decentralized/distributed:– The LMS has personal information and results

for tests and assignments– The ALE has detailed information about access

to learning material– The GRAPPLE User Model Framework (GUMF) is

used to store and share UM information– The data structures used by LMS, ALE and GUMF

may differ greatly (so conversion is needed)


Slide 14


Slide 15

Application-IndependentUser Characteristics

• Background and experience– background = user’s experience outside the application– experience = user’s experience with the application’s

hyperspace (but not content)

• Preferences– any explicitly entered aspect of the user that can be

used for adaptation– examples: media preferences, cognitive style, etc.

• Context / environment– aspects of the user’s environment, like browsing device,

window size, network bandwidth, processing power, etc.(less stable than the other characteristics)

Determining User Characteristics

• Deduce from environment:– which browser, device, network

• Deduce from user (browsing) behaviour:– e.g. selection of images visualizer– e.g. breadth-first / depth-first navigation

field-dependent / field-independent• Explicitly entered (through a form):

– background, experience, roles, goals, …


Slide 16


Slide 17

Application-DependentUser Characteristics

• Knowledge of the user– initialization using stereotypes (beginner, intermediate,

expert)– represented in an overlay model of the concept

structure of the application– fine grained or coarse grained– based on browsing and on tests

• Goals, tasks or interest– mapped onto the applications concept structure– difficult to determine unless it is preset by the user or a

workflow system– goals may change often and more radically than

knowledge


Slide 18

Modeling “Knowledge” in AES

• Moving target: knowledge changes while using the application– scalar model: knowledge of whole course

measured on one scale (used e.g. in MetaDoc)– structural model: domain knowledge divided

into independent fragments; knowledge measuredper fragment

• type of knowledge (declarative vs. procedural)• level of knowledge (compared to some “ideal”)

– positive (overlay) or negative information(bug model) can be used


Slide 19

Overlay Modeling of User Knowledge

• Domain of an application modeled through a structure (set, hierarchy, network) of concepts.– concepts can be large chunks (like book

chapters)– concepts can be tiny (like paragraphs or

fragments of text, rules or constraints)– relationships between concepts may include:

• part-of: defines a hierarchy from large learning objectives down to small (atomic) items to be learned

• is-a: semantic relationship between concepts• prerequisite: study this before that• some systems (e.g. AHA!) allow the definition of

arbitrary relationships


Slide 20

Which types of knowledge values?• Early systems: Boolean value (known/not known)

– works for sets of concepts, but not for hierarchies (not possible to propagate knowledge up the hierarchy)

• Numeric value (e.g. percentage)– how much you know about a concept– what is the probability that you know the

concept• Several values per concept

– e.g. to distinguish sources of the information– knowledge from reading is different from

knowledge from test, activities, etc.


Slide 21

Modeling Users’ Interest

• Initially: weighted vector of keywords– this mimics how early IR systems worked

• More recently: weighed overlay of domain model– more accurate representation of interest– able to deal with synonyms (since terms are

matched to concepts)– semantic links (as used in ontologies) allow to

compensate for sparsity– move from manual classification of documents

to automatic matching between documents and an ontology


Slide 22

Modeling Goals and Tasks• Representation of the user's purpose

– goal typically represented using a goal catalog(in fact an overlay model)

– systems typically assume the user has one goal– automatic determination of the goal is difficult;

glass box approach: show goal, let user change it

– the goal can change much more rapidly thanknowledge or interest

• Determining the user's goal/task is much easierwhen adaptation is done within a workflowmanagement system


Slide 23

Modeling Users’ Background

• User's previous experience outside the core domain of the application– e.g. (prior) education, profession, job

responsibilities, experience in related areas, ...– system can typically deal with only a few

possibilities, leading to a stereotype model– background is typically very stable– background is hard to determine automatically


Slide 24

Modeling Individual Traits

• Features that together define the user as an individual:– personality traits (e.g.

introvert/extrovert)– cognitive styles (e.g. holist/serialist)– cognitive factors (e.g. working memory

capacity)– learning styles (like cognitive styles but

specific to how the user likes to learn)


Slide 25

Modeling Users’ Context of Work

• User model contain context features although these are not really all “user” features.– platform: screen dimensions, browser software

and network bandwidth may vary a lot– location: important for mobile applications– affective state: motivation, frustration,

engagement

Simplified UM View (from GALE)

• UM consists of concepts with properties and/or attributes. It’s an overlay model.– concepts are identified using URIs– the user is represented as concept personal– examples:

• gale://gale.tue.nl/personal#email(email attribute of the personal pseudo-concept)

• gale://grapple-project.org/Milkyway/Star#image?title(title property of image attribute of Star concept in the application Milkyway)


Slide 26

Authoring Overview

• domain model,user model andconcept relationship typesused to define theConceptual Adaptation Model (CAM)

• adaptation code generated first in GAL (adaptation engine independent), then into GALE (adaptation engine specific rules)


Slide 27

Example: MilkyWay

• Shows information about stars, planets, moons, …

• The application is densely linked.

• Not every path is pedagogically sound


Slide 28

GAT: GRAPPLE Authoring Tool

• DM: domain model editor:– concepts, properties, resources– semantic relationships

• CRT: concept relationship type editor– to define types of pedagogical relationships– this is not normally used by authors

• CAM: conceptual adaptation model editor– to connect concepts by pedagogical

relationships (crt)


Slide 29


Slide 30


Slide 31


Slide 32


Slide 33


Slide 34


Slide 35


Slide 36

GRAPPLE CRT DefinitionCRT Data Model• general information

– unique identifier, author, name, description, creation time, update time, …• pedagogical description (free text)• structural information

– definition of sockets which are containers for concepts• graphical representation

– color and shape: defines the look of a CRT• adaptation behavior (adaptation code defines the meaning of a CRT)

– user model variables and GAL code• constraints of entities

– restrictions which concepts are allowed for a CRT and how CRTs can be connected in CAM

• domain model relations– relations to relationships between concepts in domain models

GRAPPLE TutorialSeptember 30, 2009

Slide 37

CRT: Adaptation BehaviourAdaptation behaviour is defined for each CRT• adaptation behaviour defines the behaviour of the GRAPPLE

engine • “pedagogical meaning” is formally expressed• GAL code is used for this definition

– GAL code defines adaptive presentation– GAL code also defines user model updates

• Examples:– GAL code defines which fragments to show upon access– GAL code defines how access translates to knowledge update– GUL code defines how knowledge propagates to other

concepts

GRAPPLE TutorialSeptember 30, 2009

Slide 38


Slide 39


Slide 40


Slide 41


Slide 42


Slide 43


Slide 44

GRAPPLE CAM Definition

• The CAM Tool lets you draw a conceptual adaptation model:– copy DM concepts into the sockets of a CRT.– output in visual language: what the “graph”

looks like on the author’s screen.– CAM Internal Language: Internal representation

of (incomplete) CAM models. (in XML)– CAM External Language: Language for export.

Includes DM‘s and CRT‘s used. (in XML)


Slide 45


Slide 46


Slide 47


Slide 48

Prerequisites Workshop

• The figure shows part of our “Milky Way” example.

• The different relationship types result in links in the application.

• This figure does not show prerequisites.


Slide 49

How to Understand Prerequisites

• You should study A before B– “should”: different adaptation

techniques either enforce this or give advice

– “study”: this can be access or read or take a test; result is a knowledge value

– how much knowledge is enough?– are prerequisites transitive?– “before”: this does not imply just before


Slide 50


Slide 51

What Do We Adapt in AH?

• Adaptive content and presentation:– adapting the information– adapting the presentation of that information– selecting the media and media-related factors

such as image or video quality and size• Adaptive navigation:

– adapting the link anchors that are shown– adapting the link destinations– giving “overviews” for navigation support and

fororientation support

Taxonomy

• Latest taxonomy of adaptation techniques[Knutov et al, 2009]


Slide 52


Slide 53

Content Adaptation• Inserting/removing fragments

– prerequisite explanations: inserted when needed– additional explanations: inserted when possible– comparative explanations: only when it makes sense

• Altering fragments– Most useful for selecting among a number of alternatives– Can be done to choose explanations or examples, but also

to choose a single term

• Dimming fragments– Text not intended for this user is de-emphasized

(greyed out, smaller font, etc.)– Can be combined with stretchtext to create de-emphasized

text that conditionally appears, or only appears after some event (like clicking on a tooltip icon)


Slide 54

Content Adaptation (cont.)

• Sorting fragments– Can be done to perform relevance ranking for instance

• Zoom/Scale– Can be used to emphasize or deemphasize a fragment– With text it can also be done through automatic

summarization– With video it can be done through segment selection

• Stretchtext– Similar to replacement links in the Guide hypertext

system– Items can be open or closed; system decides adaptively

which items to open when a page is accessed


Slide 55

Example of inserting/removing fragments, course “2L690”

• Before reading about Xanadu the URL page shows:– …

In Xanadu (a fully distributed hypertext system, developed by Ted Nelson at Brown University, from 1965 on) there was only one protocol, so that part could be missing.

…• After reading about Xanadu this becomes:

– …In Xanadu there was only one protocol, so that part could be missing.

…


Slide 56

Stretchtext example:the Push system


Slide 57

Scaling-based Adaptation


Slide 58

Adaptive Navigation Support• Guidance

– like an adaptive guided tour– “next” button with adaptively determined link destination

• Adaptive link generation– the system may discover new useful links between pages

and add them– the system may use previous navigation or page similarity

to add links– generating a list of links is typical in information retrieval

and filtering systems

• Variant: Adaptive link destinations– link anchor is fixed (or at least always present) but the

system decides on the link destination “on the fly”


Slide 59

Adaptive Navigation Support (cont.)

• Adaptive link annotation– all links are visible, but an “annotation” indicates relevance– the link anchor may be changed (e.g. in colour) or additional

annotation symbols can be used

• Adaptive link hiding– pure hiding means the link anchor is shown as normal text (the

user cannot see there is a link)– link disabling means the link does not work; it may or may not

still be shown as if it were a link– link removal means the link anchor is removed (and as a

consequence the link cannot be used)– a combination is possible: hiding+disabling means the link

anchor text is just plain text


Slide 60

Adaptive Navigation Support (cont.)

• Link sorting– reordering links gives them priority and thus offers

guidance

• Combinatorial techniques– think of a “menu” or partial table of contents (generated

links + annotation, perhaps + sorting)– a “local” or “global” map can be adapted by annotating

or removing nodes or larger parts– a map can also be adapted by moving nodes around– there may be contextual and non-contextual links

Example of Link Hiding

• Example from AHA!: show only most relevant links.– should be used “unidirectionally”: make more

links become available, but never start hiding previously presented links


Slide 61


Slide 62

Example:Link Annotation in ELM-ART


Slide 63

Example:link annotation in Interbook

1. Concept role

2. Current concept state

3. Current section state

4. Linked sections state

4

3

2

1

√

Adaptive Presentation (cont.)

• Adapting the layout:– to fit within another application, e.g. an LMS

• add/remove parts that do not fit within a template

– to fit within a restricted display environment, e.g. a mobile phone.

• split (partition) the presentation• zoom/scale to fit• change layout into navigation• replace video by images for limited bandwidth

– adaptation for “effect”• layout changed based on UM data


Slide 64

Adaptation Rules

• In GRAPPLE Adaptation is based on event-condition-action rules– if “event” happens (e.g. concept is requested)– and “condition” is true (e.g. all prerequisites are satisfied)– then “action” (e.g. knowledge of the concept becomes 100)

• Questions:– When is resource selection performed? (which page to

show?)– When are rules executed? Before or after serving a page?– Is rule excution safe? (there are problems with database

triggers…)


Slide 65

Adaptation / Rule Execution

• When a user requests a concept (page), should the page be adapted to the old or new user model state?– If you want to include a fragment upon the first

visit only, how would you do that?– If you show links to other pages how do you

decide whether prerequisites are satisfied? (based on the old or new user model state?)

– When we conditionally include an object, what user model state should the decision be based on?


Slide 66

Page Selection in GRAPPLE

• A concept may be associated with multiple resources– we may have a beginner and an expert page

for the same concept– the decision for resource selection is very

similar to conditional inclusion of objects…• Conclusion: the decision is based on the new

user model state (after performing user model updates)


Slide 67

Termination and Confluence


Slide 68

August 10-14, 2009ECSE Summer School 2009

Slide 69

Forward and Backward Reasoning• Two opposite approaches for adaptation:• forward reasoning:

1. register events2. translated events to user model information3. store the user model information4. adaptation based directly on user model information

• backward reasoning:1. register events2. store rules to deduce user model information from

events3. store rules to deduce adaptation from user model

information4. performing adaptation requires backward reasoning:

decide which user model information is needed and then deduce which event information is needed for that.

Adaptation in GRAPPLE: GALE

• The GRAPPLE Adaptive Learning Environment has the following main properties:– three separate components: UM server, DM/AM

server, adaptation engine (AE)– linked through an internal event bus– separation between concepts and content– adaptation rules can call arbitrary (Java) code– supports forward and backward reasoning– adaptation to arbitrary XML formats (not just

HTML)– works stand-alone or within the GRAPPLE

infrastructure (with LMSs and GUMF)


Slide 70


Slide 71

Logging in (GRAPPLE/GALE)

• GRAPPLE uses Shibboleth for a single sign-on solution

• GALE also has a stand-alone login manager– upon first login, create an account– after login, automatic redirect to requested page– supports anonymous login

• GALE also supports a “link-login manager”– direct login from within an LMS, without Shibboleth


Slide 72

GALE Processors and Modules• Processors provide the default behavior of GALE

– UpdateProcessor: performs user model updates– LoadProcessor: makes the resource data available as an input

stream– HTMLProcessor: creates proper XHTML from HTML data– ParserProcessor: parses XML data of the resource– XMLProcessor: does the actual content adaptation to any XML

document, using a number of modules– SerializeProcessor: serializes XML data found in the resource

back to an input stream– PluginProcessor: allows plugins to be added, that have direct

control over the main output of GALE based on the current concept and user

– Sequencing through “levels” associated with processors.


Slide 73

Adaptation: the XMLProcessor

• The XMLProcessor handles GALE tags through modules:– IfModule, ObjectModule: handle conditional inclusion of

fragments and objects– HTMLModule: handles the HTML tag (and e.g. inserts a

standard style sheet)– VariableModule and AttrVariableModule: return the value

of a user model attribute or an expression as simple text or as an XML attribute resp.

– MCModule: creates a multiple choice test (evaluated by a plugin)

– LinkModule: handles link adaptation (see also further)


Slide 74

Link Adaptation in GALE

• Icons can be displayed around link anchors:<property name="iconList”><list> <value>("static-tree-view".equals(gale.currentView()) ? (${#suitability} ? (${#visited}>0 ? "pre:gale:/images/WhiteBall.gif” : "pre:gale:/images/GreenBall.gif” ) : "pre:gale:/images/RedBall.gif") : null )</value></list></property>– In the view “static-tree-view” link anchors are preceded

by a green, white or red ball, based on the “suitability” and “visited” attribute values of the current concept.

– This definition may be stored in the galeconfig.xml file (which is in spring format)


Slide 75

Link Adaptation in GALE (cont.)

• The link anchor is of an adaptively determined class:– A style sheet (default gale.css) defines the actual

presentation for each link class.– The default presentation is good = blue, neutral = purple,

bad = black– deviation from the default goes into galeconfig.xml– <property name="defaultExpr" value=“( ${#suitability} ?

(${#visited}>0 ? \"neutral\” : \"good\” ) : \"bad\” ) " />– This default can also be changed by changing the value of

the #link.classexpr attribute– presentation attributes can be “inherited” from a special

layout concept (or layout attributes of a parent concept)


Slide 76

Creating GALE Applications

• Creating a conceptual structure:– domain model (concepts, conceptual

relationships like “is-a”, “part-of”, etc.)– conceptual adaptation model (pedagogical

relationships like “prerequisite”)

• Creating content as a “website”:– any XML format is supported, but XHTML is

most commonly used– use “gale” name space for adaptive elements


Slide 77

David Smits

En de gale namespace is:http://gale.tue.nl/adaptation.Maar staat op slide 74.

Three Types of Authoring• A concept can be associated with one

resource (page); each page is authored separately.

• A concept can be associated with a template resource (shared between many concepts); the template “includes” content fragments (with URLs from the concept’s attributes).

• A concept may rely on a presentation engine to generate a layout and “include” content fragments (from the concept’s attributes).


Slide 78

Authoring Pages Separately


Slide 79

Template-Based Authoring


Slide 80

Fully Generated Approach


Slide 81

Creating a GALE Page• It’s “mostly” like XHTML but needs name spaces:

<html xmlns=http://www.w3.org/1999/xhtml xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xmlns:gale=http://gale.tue.nl/adaptation xsi:schemaLocation="http://www.w3.org/1999/xhtml

http://www.w3.org/2002/08/xhtml/xhtml1-strict.xsd”

• HTML tags are used without name space, GALE tags with name space:– adaptive link anchor:

<gale:a href=“newconcept”>anchor text</gale:a>– conditionally included object:

<gale:object name=“conceptname” />– conditionally included in-line fragment:

<gale:if expr=“${someconcept#someattribute}>0”> <gale:then>conditional text</gale:then></gale:if>


Slide 82

http://www.w3.org/1999/xhtml

http://www.w3.org/2001/XMLSchema-instance

http://gale.tue.nl/adaptation

http://www.w3.org/2002/08/xhtml/xhtml1-strict.xsd

GALE Expressions

• References to concepts/attributes using URIs:– ${#attribute} refers to an attribute of the current concept– ${concept#attribute} refers to an attribute of the named

concept of the current course– ${gale://server.where:port/gale/course/concept#attribute}

refers to an attribute of a concept of some course somewhere on another server.

• Java expressions, escaping reserved characters (<>)– ${concept#knowledge} > 50

(is the knowledge of the concept greater than 50)– gale.concept().getApplication()

(gives the name of the course of the current concept)


Slide 83

GALE Expressions (cont.)• (more) shorthand notation examples:

– ${->(parent)?type}the value of the “type” property of the parent concept

– ${->(parent)?type}.equals("page")whether the value of the type property of the (first) parent concept is equal to “page”

– ${->(parent)<-(parent)}.lengththe number of siblings of the current concept, based on the ‘parent’ relationship

– ${details<-(related)}an array of concepts that have a ‘related’ relation to the ‘details’ relative concept

• Note: the < and > signs must be escaped


Slide 84

GALE Expressions (cont.)

• (more) shorthand notation examples:– #{->(parent)#visited, ${->(parent)#visited}+1};

increments the UM variable ‘visited’ of the parent concept

– #{gale://gale.tue.nl/personal#history, gale.conceptUri()};store the current concept URI in a variable called ‘history’ in the concept ‘gale://gale.tue.nl/personal’


Slide 85

Example Fragment of a Page

<gale:a href="installation”>Installation instructions</gale:a>

This section describes how to install GALE on a Windows or Linux system, and how to configure it for use with the mySQL database. <gale:if expr="${installation#knowledge}==0"> <gale:then> You are advised to study this part first in order to set up your own local server on which you can experiment with GALE. After this step you can opt to either first study GALE in detail, or to jump right into the <gale:a href="example>example</gale:a> that gives you hand-on experience with the creation of a GALE

application. </gale:then> </gale:if>


Slide 86

Example “Header” for Milkyway

<variable name="gale://gale.tue.nl/personal#name" />this tag is replaced by the learner’s name (shown in the page)<variable expr='gale.concept().getApplication()' />this tag is replaced by the name of the current application<variable expr="${#knowledge}.intValue()"/>this tag is replaced by the knowledge level of the current

concept<plugin> <name>logout</name>

<linkdescription>logout</linkdescription> </plugin>when the learner clicks on the link (s)he is logged out


Slide 87

Milkyway: Page-Based Approach<h1>Jupiter</h1><h2>Image of: <u>Jupiter</u></h2><br/><img src="../img/img_jupiter.jpg" width="300"/><br/><h2>Information:</h2>Jupiter is the fifth planet from the Sun and

the largest planet within the Solar System.[10] It is two and a half times as massive…

<br/><b>The following <gale:a href=“Moon”>Moon(s)</gale:a> rotate around Jupiter:</b>

<ul> <li><gale:a href=“Ganymede”>Ganymede</gale:a></li> <li><gale:a href=“Europa”>Europa</gale:a></li> …</ul>


Slide 88

Page about a planet (in this case Jupiter).

Note the specific structure of the layout.


Slide 89

Page about a planet (in this case Saturn).

Note that the layout is identical to that of the Jupiter page.


Slide 90

Milkyway Template Page

<h1><gale:variable expr="${?title}"/></h1>this prints the title property of the concept, for instance “Jupiter”<h2><gale:variable expr="${#image?label}"/>

<u><gale:variable expr="${?title}"/></u></h2>this prints the label property of the image attribute,and then the title property of the concept again<br /><img width=“300”>

<gale:attr-variable name="src" expr="${#image}”/></img>this constructs the attributes of the <img> tag to show the

imageof which the URL is in the image attribute


Slide 91

David Smits

de <gale:attr-variable name="width" expr="300" /> is misschien een beetje raar. Je zou ook gewoon <img width="300"> ... </img> kunnen schrijven.

Milkyway Template Page (cont.)

<h2><gale:variable expr="${#info?label}"/></h2>this prints the label of the info attribute: “Information:”

<gale:object><gale:attr-variable name="data" expr="${#info}" /> </gale:object><br />

this inserts the object with as “data” xml-attribute the “info”attribute of the current concept (this is the information

paragraph)


Slide 92

Milkyway Template Page (cont.)<gale:if expr="${<-(isMoonOf)}.length > 0">

<gale:then> <b>The following <a><gale:attr-variable name ="href” expr="${->(parent)<-(rotatesAround)?title}"/>Moon(s) <gale:adapt-link/></a> rotate around <gale:variable expr="${?title}"/>:</b>

<ul><gale:for var="concept" expr="${<-(isMoonOf)}"> <li><gale:a><gale:attr-variable name="href”

expr=""%concept""/> <gale:variable expr="${%concept?title}"/> </gale:a></li> </gale:for></ul> </gale:then></gale:if>


Slide 93

Milkyway Template Page (cont.)

Here is the additional bit to generate “Is Planet of: Sun” <h4>Is <gale:a><gale:variable expr="${->(parent)?

title}"/> <gale:attr-variable name ="href" expr="${->(parent)?title}"/></gale:a> of:

<gale:a><gale:variable expr="${->(isPlanetOf)?title}"/> <gale:attr-variable name ="href” expr="${->(isPlanetOf)?title}"/> </gale:a></h4>


Slide 94

Layout in GALE

• Layout can be defined in a “Layout” concept– it has an attribute “layout” with a “default”

• example: <struct cols="20%;*”><view name="static-tree-

view"/><content/>

</struct>”• layout can be overridden by the application

– concepts can “extend” each other: concepts can extend Layout to inherit the layout attribute (with its default)


Slide 95

“Complex” Layout Example

• The “hypermedia” course has adaptive layout:(escaping not done to make it easier to read)

<attribute name="layout" type="java.lang.String”> <default>(${gale://wwwis.win.tue.nl/2ID65/introductorypart#done} ? (${?type}.equals("page") ? “<struct cols="20%;*”> <view name="static-tree-view"/> <content/> </struct>” : “” ) : “” )</default>

• If introductorypart is done then there is a non-trivial layout for pages, else there is no layout.


Slide 96

Steps to make GALE work• In order to install GALE stand-alone you need:

– JDK 1.5 or 1.6 (http://java.sun.com/javase/downloads/?intcmp=1281)

– Maven 2 (http://maven.apache.org/download.html)– Tomcat 6 (http://tomcat.apache.org/)– MySQL 5.1

(http://dev.mysql.com/downloads/mysql/5.1.html#downloads)

• You also need:– the permission to run services, and to create tables in

MySQL– a working network connection at least during setup– GALE (downloadable and available on stick at the tutorial)


Slide 97


Slide 98

Generic User Modeling Systems

• Adaptive Systems with built-in UM:– close match between UM structure and AS needs– high performance possible (no communication

overhead)– UM not easily exchangeable with other AS

• AS using a generic User Modeling System– cuts down on AS development cost– introduces communication overhead– unneeded features may involve performance

penalty– UM can be shared between AS


Slide 99

Requirements for Generic UM Systems

• Generality, including domain independence• Expressiveness and strong inferential capabilities• Support for quick adaptation• Extensibility• Import of External User-Related Information• Management of Distributed Information• Support for Open Standards• Load Balancing• Failover Strategies• Transactional Consistency• Privacy Support


Slide 100

Requirements for Sharing UM Data

• Sharing a technical API is not enough:– the AS must translate its internal user identities

to the UM's user identities (and vice versa)– data about users need to be standardized– shared ontologies are needed for different AS

dealing with the same domain (ontology alignment)

– agreement on who can update what– agreement on meaning of “values” in the UM

• “Scrutability” of UM:– UM data must be understandable for the user– users must have control over their

UM data


Slide 101

Requirements for GUMF• User model is inherently distributed:

– The LMS contains fairly stable information about the user (and also some assessment results)

– The ALE contains mainly dynamically changing information about the user

– There may be several components of each type• Different UM services may contradict each other

– conflict resolution needed• Not every application is allowed to access/update

UM data on every server– elaborate security/privacy settings needed

Adding UM data to GUMF

• GRAPPLE applications use GRAPPLE statements to communicate UM data

• Registered clients have their own dataspace: subset of ‘own’ statements, derivation rules and schema extensions

• Derivation rules generate new Grapple statements

• Data can be declared public or private


Slide 102

Retrieving GRAPPLE Statements

Three ways to retrieve statements(plus combinations):

Pull: Simple query interface to retrieve statements that match a certain pattern

Push: Subscribing to a stream of statements; activated upon an event

Manual: Browsing interface (for admin usage or scrutability)


Slide 103

Grapple Statement Structure

Main Part• Subject Subproperty: User• Predicate Property (specified in ontology)• Object Value of the statement• Level Qualification/level (if applicable)• Origin The statement in its original form (if applicable)

Meta Part• ID Globally unique• Creator Entity that created the statement• Created Time of creation/submission of statement• Access Data for any kind of access control mechanism• Temporal Constraints on validity of statement• Spatial In which contexts is statement valid• Evidence Refers to or embodies formal evidence• Rating Level of trust (to be developed)


Slide 104

Example GRAPPLE Statement

“Peter is interested in Sweden”

gc = http://www.grapple-project.org/grapple-core/foaf = http://xmlns.com/foaf/0.1/

gc.Statement {gc:id gc:statement-peter-2009-01-01-3234190;gc:user http://www.peter.de/foaf.rdf#me;gc:predicate foaf:interest;gc:object: http://en.wikipedia.org/wiki/Sweden;

}

(Metadata omitted for simplicity)


Slide 105

http://www.grapple-project.org/grapple-core/

http://xmlns.com/foaf/0.1/

http://www.peter.de/foaf.rdf#me

http://en.wikipedia.org/wiki/Sweden

RDF/XML Serialization“Peter is interested in Sweden”<rdf:RDF xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax#“ xml:base=“http://www.grapple-project.org/statements/“

gc = “http://www.grapple-project.org/grapple-core/”foaf = http://xmlns.com/foaf/0.1/>

<rdf:Description rdf:ID=“gc:statement-peter-2009-01-01-3234190“> <user> http://www.peter.de/foaf.rdf#me </user> <predicate> foaf:interest </predicate> <object> http://en.wikipedia.org/wiki/Sweden object> <creator> www.l3s.de/~herder/foaf.rdf#me</creator> <created> 2009.01.01 </created>

… </rdf:Description></rdf>


Slide 106

http://www.grapple-project.org/grapple-core/

http://xmlns.com/foaf/0.1/

http://www.peter.de/foaf.rdf#me

http://en.wikipedia.org/wiki/Sweden

What does ‘interest’ mean?This is defined in the FOAF ontology (any kind of

ontology can be used)<rdf:Property rdf:about="http://xmlns.com/foaf/0.1/interest" vs:term_status="testing" rdfs:label="interest" rdfs:comment="A page about a topic of interest to this

person."> <rdf:type

rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>

<rdfs:domain rdf:resource="http://xmlns.com/foaf/0.1/Person"/> <rdfs:range

rdf:resource="http://xmlns.com/foaf/0.1/Document"/> <rdfs:isDefinedBy rdf:resource="http://xmlns.com/foaf/0.1/"/></rdf:Property>


Slide 107

The GRAPPLE Infrastructure


Slide 108

The GRAPPLE Event Bus• On the bus the eventGEBListener web service

collects events sent by LMS, GUMF, GALE• On the component side an eventListener with web

service eventEventListener processes events rerouted by GEB

• Components may register methods with GEB to listen to the event bus.

• GEB only sends events to components that listen to that specific event.

• GEB has a listMethods() service to allow components to find out which methods can be called


Slide 109

Single Sign-on:Shibboleth• open-source software package for web

SSO across or within organizational boundaries, based on the open standard Security Assertion Markup Language (SAML).

• allows sites to make informed authorization decisions for individual access of protected online resources in a privacy-preserving manner.


Slide 110

Shibboleth

• Identity Provider - asserts digital identities using SAML, supplies information about a user to a Service Provider;

• Service Provider - gathers information about users (SAML assertions) to protect resources.

Shibboleth in GRAPPLE

• Use Shibboleth for Single Sign On (SSO) between GRAPPLE (the GRAPPLE Event Bus is the GRAPPLE component directly involved in this) and LMSs – Moodle, Sakai, Claroline, CLIX, learn eXact.

Shibboleth IdP in GRAPPLE

• Shibboleth IdP is used to assert unique digital identities to the users:– connects to authentication and user

data systems of GRAPPLE and LMSs, – provides information about how a user

has been authenticated, • provides user identity information from the

data source.

GRAPPLE (and LMSs)

– initiate the requests for authentication and attributes,

– process incoming authentication and attribute information.

Shibboleth & GRAPPLE

Future Work• A lot remains to be done before GRAPPLE can be

distributed to authors/end-users:– Authoring tools must be improved (based on

feedback from testers)– Compilers from authoring tools to GALE need to

be completed– Some components still need to be connected to

GEB– More real courses need to be developed/served

through GRAPPLE– Evaluators / testers are most welcome!


Slide 116

Evaluation

• Please visit the link below and answer a few questions about the tools we discussed today (mostly the authoring parts)

• http://www.surveymonkey.com/s.aspx?sm=6yf5OChOqM7KmM8vG2oN5Q_3d_3d

04/21/23GRAPPLE Tutorial

Slide 117

http://www.surveymonkey.com/s.aspx?sm=6yf5OChOqM7KmM8vG2oN5Q_3d_3d

http://www.surveymonkey.com/s.aspx?sm=6yf5OChOqM7KmM8vG2oN5Q_3d_3d

grapple tutorial paul de bra eindhoven university of technology with contributions from the entire...

Documents

grapple tutorialslide

grapple tutorialseptember

grapple tutorialwhat

experience of grapple

grapple tutorialpaul

grapple authoring toolused

entire grapple teamseptember

user model representation