An extensible approach to visually editing adaptive learning activities and designs based on services

This article appeared in a journal published by Elsevier. The attached
copy is furnished to the author for internal non-commercial research
and education use, including for instruction at the authors institution
and sharing with colleagues.
Other uses, including reproduction and distribution, or selling or
licensing copies, or posting to personal, institutional or third party
websites are prohibited.
In most cases authors are permitted to post their version of the
article (e.g. in Word or Tex form) to their personal website or
institutional repository. Authors requiring further information
regarding Elsevier’s archiving and manuscript policies are
encouraged to visit:
http://www.elsevier.com/copyright

Author's personal copy
An extensible approach to visually editing adaptive learning
activities and designs based on services
Juan Manuel Dodero a,n, A´lvaro Martı´nez del Val a, Jorge Torres b
a Computer Languages and Systems Department, Universidad de Ca´diz, C/ Chile 1, 11002 Ca´diz, Spain
b Computing Systems Department, Instituto Tecnolo´gico y de Estudio Superiores de Monterrey, Av. Epigmenio Gonza´lez 500, Fracc. San Pablo,
76130 Santiago de Quere´taro, Qro., Mexico
a r t i c l e i n f o
Keywords:
Domain-specific languages
Learning design
Learning management systems
a b s t r a c t
Learning management systems (LMS) provide an operational environment in which an
online course can be created and later executed. Inter-operation between creators and
their authoring facilities, and the LMS execution engine are based on defining standards
and specifications, such as the IMS Learning Design (LD). Because an LMS better serves
as a course player than as a course creator, a large number of approaches and
environments for standards-compliant course authoring have been developed. These
approaches and environments propose a number of issues that deal with how
adaptations are edited and how to define the connection of learning activities with
external learning applications and services. These questions have raised concern, mostly
because of the excessive commitment of the creators’ methods and tools used with an
educational modeling language, as well as the isolation of the language used to describe
the course from the host LMS. This work describes an abstract, extendible language used
to specify the learning design of a course, which can be transformed into any LD
language as required by the execution environment. The language is used from a
generative authoring environment that offers the possibility of editing web services as
an additional resource to assess learning activities.
& 2010 Elsevier Ltd. All rights reserved.
1. Introduction
A learning design defines a set of people in specific
groups and roles engaged in a structure of learning
activities, resources and services, which are the main
components used to describe a learning experience. The
learning design of a course is made explicit by means of
an Educational Modeling Language (EML), which provides
a framework of elements used for its formal specification
[1,2]. EMLs are useful in the representation of all learning
activities, resources, services and user roles that take part
in a course supported by computer technology. The life
cycle of such courses begins with the creation of an
EML-based description of the course and ends by running
it in a Learning Management System (LMS)—such as
Moodle, .LRN or Sakai—or execution engine—such as
CopperCore [3] or GRAIL [4].
EMLs can be classified as authoring languages or
exchange languages [5], depending on the emphasis put
on the authoring or delivery side, respectively. Exchange
EMLs usually include low-level elements as required by
the execution engine, but they are farther than authoring
EMLs from instructors’ needs to describe a course. A more
detailed classification of EMLs for collaborative learning
can be found elsewhere [6]. The main representative of
the EMLs that aim at representing collaborative learning
processes is the IMS Learning Design (LD) specification
[7], which has become the standard form for representing
collaborative learning courses among e-learning systems.
Contents lists available at ScienceDirect
journal homepage: www.elsevier.com/locate/jvlc
Journal of Visual Languages and Computing
1045-926X/$ - see front matter & 2010 Elsevier Ltd. All rights reserved.
doi:10.1016/j.jvlc.2010.08.007
n Corresponding author. Tel.: +34 956015784; fax: +34 956015139.
E-mail addresses: juanma.dodero@uca.es (J.M. Dodero),
alvaro.martinez@uca.es (A´.M. del Val), jtorresj@itesm.mx (J. Torres).
Journal of Visual Languages and Computing 21 (2010) 332–346

Author's personal copy
Although IMS LD is intended to be an exchange EML,
courses must eventually be managed and executed in a
concrete LMS that might not be able to import IMS LD-
compliant courses. For instance, Moodle can import SCORM
contents—albeit not supporting a fully compliant version,
but support for IMS LD is still a promise [8,9]. LMS usually
integrate their own facilities, consisting of editors based on
web forms, to create courses. This does not, however, make
having a standard way of exchanging a collaborative
learning course specification across LMS any easier.
If having a usable approach for editing learning
resources and designs is still an issue, it becomes more
difficult when a learning course requires the access to
external web services as a means of providing support for
the learning process [10]. Access to the learning service
from a learning design is usually defined through generic
WSDL-based service descriptions required to interact with
specific instances of the service [11]. Such generic service
interfaces, however, do not facilitate course authoring.
When the access protocol is based on Representational
State Transfer (ReST), activities can be provided with a
usable interface to access external services [12], but this
has not been widely included in LD authoring approaches.
This paper explains a new visual and generative
approach to LD course modeling that enables the integra-
tion of different EMLs and LMS exchange formats into an
integrated environment. The environment provides visual
and text-based editing views that enable the forward and
reverse engineering of e-learning activities and services.
This means that you can edit the same course from either
the visual environment or from the text-based editor,
meaning the changes made from one will automatically
be applied to the other view.
The rest of the paper is structured as follows: Section 2
outlines both the main topic of editing adaptive units of
learning, as well as the reasons for the provision of visual
editing approaches for that aim. Section 3 describes the
existing methods and tools that use visual LD editing
approaches, while Section 4 illustrates our generative and
visual approach to edit adaptive learning courses. The
evaluation of the approach is then described in Section 5,
and finally, Section 6 states various conclusions and future
work.
2. Issues and motivations
The IMS LD specification describes a framework of
technical formalisms for learning designs that are classi-
fied in three levels: namely A, B and C. Level A formalisms
include elements to describe user roles, learning and
support activities, activity structures, learning resources
and services and role-parts (i.e. the binding of activities to
roles). With level A elements, a static snapshot of the
learning design can be defined. The core elements of level
A are activities, which can be learning activities or support
activities depending on their relationship with the
learning objectives of the course. Activities can be
aggregated as activity-structures that can be one of two
kinds, i.e. sequence or selection. Activities are run by
someone playing the role of a learner or staff member. The
method is a structured organization of activities based
upon the metaphor of a theater play, which includes play
and act elements. Other major level A components are
learning objects and learning services, which can be
grouped in environments and then linked to activities.
The dynamic part of the specification is provided by
level B and C formalisms [13], which are used to adapt the
execution flow of the learning process and use notifica-
tions to dynamically set activities. Level B elements allow
for the description of dynamic adaptations that can occur
on the learning flow according to events and conditions
that might happen during the course run [14]. Level B
elements are properties, that represent values on the
branching decisions begin made; conditions, that express
combinations of conditional clauses on which the learning
flow can branch; and show or hide elements to show or
hide activities on each branching flow. Such formalisms
are described in standard XML manifest files and pack-
aged along with web content resources as a Unit-of-
Learning (UoL) for each learning course delivered.
The most significant authoring approaches prevent
users from keeping their distance from the IMS LD
specification, so instructional designers have to learn
how to use these technical concepts that are far from their
pedagogical background [15]. The result is that instruc-
tional designers and technology-enhanced learning re-
searchers have found it difficult to edit an IMS LD-based
UoL [16] from the bare IMS LD specification. Several
authors stress this issue, and hence they propose LD
authoring approaches in order to ease editing a UoL [5,17].
Editing a learning course according to the complete
model of IMS LD is cumbersome [1,15,18], so visual
methods and environments have been provided. Visual LD
approaches and tools define a visual source language
[19–22] from which an IMS LD UoL can be created. These
methods provide a model of visual LD elements very
similar to those of IMS LD level A formalisms (i.e. roles,
activities, learning flow connectors, etc.), and map them to
the required descriptions of IMS LD elements in a UoL.
Even so, not many visual LD editing languages that keep
their distance from the IMS LD level B formalisms have
been provided.
Previous research suggests that the IMS LD informa-
tion model has some issues with expressiveness and
scalability that hinder its adoption and full provision
[5,15,17]. For instance, each conditional flow that follows
another conditional flow in IMS LD will expand the
complexity of the course specification by a multiplicative
factor. We find two main reasons that have led LD
researchers and technical developers to elide the level B
part of the IMS LD specification:
� Visual editing abstractions are often too dependent on
the underlying EML formalism of the UoL being
generated. This issue is especially relevant when such
formalisms are difficult to understand or use, as they
are in the case of IMS LD level B elements.
� Major LMS do not have an LD player available to host
and run learning designs. This has been a hindrance to
the adoption of LD editing tools, mostly because LMS
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346 333

Author's personal copy
use internal solutions to define and store learning
activities, bind them to users and run them in sequences.
Even the most widespread LMS have taken a while to
deploy an IMS LD player (e.g. .LRN [4]) or sometimes they
lack one. Moodle LMS is an example of the latter. It
provides a complete environment to create courses, define
activities, manage and grade students and so forth. The
types of activities provided by Moodle include lessons,
assessments, forums, chats and wikis, among others. No
facilities, however, are provided to specify the adaptation
of the flow of activities, or to create a complex assessment
associated with an activity. Since Moodle is not an EML,
there is no standard language specification to store and
exchange a course. An XML language for Moodle backups
exists that can be used for this purpose, but its structure is
grossly complex, and thus difficult to be edited. Conse-
quently, when editing a Moodle course we find similar
issues to those of creating an IMS LD-compliant UoL.
The objective of this research is to provide an abstract
and extendible LD authoring approach that enables the
creation of courses without being tied down to the
technical formalisms of the underlying EML, execution
engine, or LMS. The proposed approach must be capable of
generating courses to be held in a specific LMS as well as
providing an inter-operable format to define, store and
run learning activities and external services.
3. Related work on visual learning designs
Exchange EMLs have features that are required to run
the course in an execution engine or player, but which
might not be of interest to the learning designer [5]. IMS
LD is an example of an exchange EML, because of its
elements defined in level B. On the other hand, authoring
EMLs are closer to the instructional designers’ needs and
practices. Visual LD languages belong to the authoring
class of EMLs, but they require a transitional step before
an edited course can be delivered to the player. The basics
of the operation of a visual LD approach are to differ-
entiate between the course language model known by the
instructional designer (i.e. the source model) and the
language model of the course artifact that is eventually
delivered (i.e. the target model), such as the IMS LD
language or other exchange EML. Here we summarize the
main visual approaches to editing learning designs,
highlighting those that have produced an available visual
authoring environment:
� The ASK Learning Design Tool [20] relies on user-
defined visual representations of IMS LD level A
formalisms from which an XML-based description of
the target UoL can be generated. Visual shapes, icons,
connectors and all source elements are kept close to
the core IMS LD level A model.
� The MOT+LD approach [22] is to reuse and later adapt
a knowledge-based modeling tool used to define
models of knowledge, competences, pedagogical struc-
ture, materials and delivery, which are then used to
generate a UoL compliant with the IMS LD level A.
� The UML4LD solution [23] defines a UML profile plugged
into a commercial meta-CASE environment that is used
to reversely engineer IMS LD level A learning designs. In
this approach, a UML diagram is generated from an IMS
LD-based UoL. Although it cannot be considered a visual
LD approach, it introduces interesting concepts about
meta-modeling, domain-specific languages (DSL) and
model-driven development of LD [24]. Understanding
the delivered models requires technical knowledge of
UML, which can serve as a barrier [25].
� ReCourse [21] is the visually improved successor of the
Reload IMS LD editing tool. Usability improvements
include a visual overview of the flow of activities in a
UoL, drag and drop facilities to define relationships
between elements of the LD, and a generally improved
interface design. Some obscure elements of the IMS LD
specification have been overridden—i.e. plays named
as courses—or hidden—i.e. role-parts are inferred from
the relationships between roles and activities. Provid-
ing a visual metaphor for level B properties and
conditions, however, is still an issue.
� The e-LD approach [5,18] proposes the authoring of
IMS LD level A elements by providing a visual work-
flow-like source model that must be transformed into
an IMS LD UoL. The visual source language supports
the level B conditions by adding flowchart-like branch-
ing representations, which are more attainable for the
pedagogical designer.
� Another attempt to lower the barrier imposed by the
IMS LD level B specification is to use visually rich
sequencing graphs [17] that authors can use to define
learning flow strategies, which can be eventually
converted into a playable UoL. This can solve the
limitations imposed by the IMS LD specification when
defining complex sequences (e.g. loops and cycles in
the learning flow). However, sequencing graphs are
still not a friendly language for instructional designers
and pedagogues. An interesting contribution from this
work is the hypothesis of scarce scalability in the IMS
LD specification, due to the excessive number of level B
properties and conditions required for even the least
complex of learning flows.
� LAMS [26] uses its own source LD model as a visual
authoring tool used to edit activity sequences. These can
include branching, gates, groupings and other visual
elements to specify adaptations in the flow of activities
of learners. Sequences are stored in a non-standard XML
based form called LAMS LD, which can then be exported
to IMS LD level A, but losing all the information that
enables the adaptation of the sequence flow for which
the IMS LD level B is intended.
� CompendiumLD [27] is a visual tool used to describe a
learning design that is defined as a set of static HTML
pages. It is useful to sketch the sequence of a course as
instructions to be delivered to the course participants,
but it does not deliver any executable artifacts that
comply with IMS LD or other specifications. Eventually
the instructional designer must use another tool if he
or she needs to make a playable UoL.
� The Graphical Learning Modeller (GLM) [28] is a visual
editor that delivers IMS LD conformant UoLs by hiding
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346334

Author's personal copy
certain level A and B elements to reduce instructors’
knowledge of the IMS LD specification. Level B
elements are hidden inside interactions or add-ons,
which are predefined evaluation activities for text
work, uploading files, question and answers and
multiple-choice tests. This approach is similar to LAMS
tools, but limited to four types of activities. Both GLM
and LAMS require the defining of a new add-on or tool
for each new type of activity requiring assessment.
� Other approaches that were not initially intended to be
visual LD tools use visual languages to generate the basic
structure of a UoL, either from a selected template [29] or
from a design pattern [30]. These abstractions provide a
simplification of the LD authoring process by means of
parameterized IMS LD-based pieces that must be
instanced before obtaining the UoL. For example, the
COLLAGE tool provides a visual abstraction of patterns to
edit a learning design. These tools are not intended to
edit templates, so they are restricted to the predefined
set that comes with the tool.
� Graphical LD modeling tools have also been used for
simulations. The semantics of state charts inspired the
MoCoLADe graphical notation [31], through which the
designer can trace the path of a group of users that
execute a collaboration script. MoCoLADe supports
IMS LD as the export format of the edited scripts, but it
is restricted to its structural constraints. IMS LD
elements are managed only at the level of the exported
IMS LD UoL, without the availability of an equivalent
abstraction at the source level.
In summary, most solutions use IMS LD as either both
the source and target models, or they restrict the source
model to the elements of the IMS LD level A model. Only a
few approaches tackle the IMS LD level B elements.
Besides this authoring issue, there is another issue related
with the EML as a means of course delivery and exchange.
Apart from LAMS, all the visual tools analyzed have in
common the idea that the target model of the generated
LD must be run in an IMS LD specific player. The LAMS
exception uses a non-standard format to store and
exchange a course activity sequence, which must be
deployed and run on LAMS-specific players, as well as
Moodle and other relevant LMS. Therefore, we propose
the need to define a more extendible way of authoring
and exchange EML-based courses that are able to run in a
common LMS or EML player.
4. The FLEXO generative learning design approach
The FLEXO LD approach is based upon the definition of
a generic LD language with a core set of elements related
to the description of activities and learning flows, plus a
number of add-ons that enable extended capabilities
concerning the representation of roles, target language-
specific extensions and web service integration. The
FLEXO language is available in a dual environment, one
that includes both visual as well as text-based course
editing. It can generate and export EML- or LMS-specific
deliverable courses.
The solution provided by FLEXO is grounded on the
conceptual model shown in Fig. 1. The FLEXO model is a
framework in which IMS LD, Moodle and other formats
can be readily understood and integrated. The core
concept of the model is the Activity class. An activity can
be associated with a set of Resources, which represent the
learning objects and services required to deploy the
activity in a web environment. Because the usual way to
adapt the learning flow is through assessments, the
AssessmentActivity does just that—it associates an activity
Fig. 1. The FLEXO conceptual model includes activities, resources, learning flows and assessment-based adaptations.
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346 335

Author's personal copy
with an assessment holding the Parameters required for
adaptation on the flow of activities. The Flow concept
represents the conditional expressions used to alter the
flow. A set of roles can be defined and mapped to the
assessment activities in order to provide advanced models
of assessment (e.g. self-assessment, peer assessment and
co-assessment). The Assessment class is a special kind of
resource that is associated with an AssessmentActivity. The
operational semantics needed for evaluating flow condi-
tions and choosing the correct conditional branch are the
same as those of regular flow charts. Since the usage of
the target language semantics is assumed, we do not
expand on it.
4.1. Generative scheme
The architecture of the visual LD authoring system is
based on a visual language specification plus a text-based
intermediate language, which are explained below. Both
languages consider the FLEXO conceptual model to be the
basis of representation for the learning design of a course.
They are available for authoring using a visual tool whose
architecture is depicted in Fig. 2:
� The visual editing tool is the users’ front-end when
authoring a learning design. The visual language
provides instructional designers with a source abstrac-
tion to edit common elements of a learning design,
such as activities, roles, learning flows and assessment-
based adaptations.
� The output of the visual tool is a text file described in
an intermediate language generated from the concep-
tual model. These files can also be edited using a text-
based language. The authoring tool follows a forward
and reverse engineering approach, in which text-based
course specifications can be generated from visual
designs and vice-versa.
� From a textual LD specification, a set of target
languages can be generated. The component in charge
of this is a parser that follows the meta-model of the
target language in which the course must be delivered.
As can be read in the following, the main components
of the authoring system are described, beginning with the
FLEXO language specification, including some examples of
visual and text-based learning designs, and ending with
an explanation of how EML- and LMS-specific courses are
delivered after generating appropriate text-based repre-
sentations of each course design.
4.2. Generative language
The FLEXO visual language is intended to represent
activities, resources, adaptations and user roles of a
learning design. The visual representation of LD elements
is depicted in Fig. 3 and further described in this section.
The language elements that deal with activities are simple
activities (Fig. 3a), assessments (Fig. 3b), composite activities
(Fig. 3c), assessment activities (Fig. 3d), parameters, simple
flows (Fig. 3e), conditional (Fig. 3f) and optional flows
(Fig. 3g). Roles (Fig. 3h) are used to associate activities,
resources and services with actual users.
Some language elements and interfaces must describe
characteristics that are specific to the target language
generated. These are included in the course description as
attributes, which are declarative tags or markups asso-
ciated with certain course elements to indicate the
language-specific semantics of the course [32]. Tagging
has the syntax of @aspect:definition, where the aspect part
defines the type of annotation and the definition part has
a specific syntax depending on the type of annotation.
Fig. 2. Main architectural components of the visual and generative LD editing system.
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346336

Author's personal copy
Two types of aspects have been defined, i.e. language
aspects and resource or service aspects. Language aspects
are used to describe specific features of the target EML or
LMS, such as a property-value pair of an EML or a
configuration value of a concrete LMS. Resource and
service aspects are used to describe the integration of a
web-based resource or service, including their Uniform
Resource Interface (URI) or the ReST interface of a learning
service operation [12].
These extension elements based on attributes make
possible the integration of target language specifics with the
generic structure of the course, thus adding features to the
core definition of activities without losing its generality.
Some examples of the application of the attribute-based
extension approach as applied to IMS LD, Moodle and
ReST-based services are explained below.
Editing the EML-specific markups can be done on
either the text-based intermediate language or by using
the visual user interface of the editing environment,
which has been prepared for that purpose.
4.2.1. Adaptations on the learning flow
The core language elements that deal with the descrip-
tion of activities and the adaptation of the activities learning
flow are the following:
� course: is the main container entity, composed of
activities, roles, and a set of references that relate to
their components.
� activity: is the container of resources and services and
is associated with a number of user roles which can
execute it. Activities can be simple or composite, as
described next:
J simple_activity: is formed by a resource, a title and a
description. This rather simple description expands
to include the features of target languages that are
described in full later on the paper.
J composite_activity: is a group of one or more (either
simple or composite) activities, plus an optional
specification of the learning flow that sequences
them.
� assessment: may contain typed parameters (i.e. boo-
lean, numeric, strings, or collections). The assessment
definition is optional, since some target languages do
not allow for the use of assessment facilities.
� assessment_activity: is a dual entity, consisting of an
activity description plus an optional assessment.
� flow: indicates sequence relations among activities. A
flow can be simple, indicating a mandatory one-way
sequence along two activities; conditional, which can
contain conditions to drive the flow along activities; or
optional, which splits the flow along a number of
parallel paths of activities.
As an example, Table 1 shows the FLEXO text-based
specification of an online course with an assessment
activity container that contains a simple activity, an
assessment and a conditional flow.
With these core structures in mind, most EMLs can be
represented. If the target language does not include a
valid element for mapping a concept of the FLEXO source
model, this element is ignored at this level of the
transformation. This is the case, for instance, of integrated
assessment activities or conditional flows when generat-
ing a Moodle course, which can only represent sequential
flows.
4.2.2. User roles
The definition of user roles is very dependent on the
target course language. Role definition of the FLEXO
Fig. 3. Summary of the FLEXO visual language elements.
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346 337

Author's personal copy
model, however, must be as generic as possible. The
model includes three basic role elements by default:
� teacher: can access and monitor learning activities.
� learner: can access activities to achieve the course
learning objectives.
� evaluator: can set the values of an assessment activity.
The basic roles are not exclusive so that new roles can
be defined as combinations of the basic ones by multiple
inheritance, i.e. a new role inherits the access privileges of
its parent roles. This way, a new role that is inherited
from an evaluator and a learner can be defined to obtain
the permissions required to carry out peer and self-
evaluations on certain activities.
The FLEXO role definition is only a starting point. In
essence, the target language (e.g. IMS LD or Moodle) can
redefine and manage its roles conveniently on the basis of
our role model. The defining of roles is optional, since
some LMS courses do not consider roles as a modeling
element.
The structure of a course is the same as in Table 1, but
added is a section for the defining of roles. By default, if no
role defining is added to the course, the basic ones are
automatically assigned to all activities and assessments.
Table 2 shows an example of the course flow specification
of Fig. 4, having two roles: one that extends the teacher
and learner (e.g. to allow learners to behave as tutors in
certain activities) and another that extends the learner
and evaluator (e.g. to allow a learner to evaluate peers on
an activity).
4.2.3. EML- and LMS-specific course extensions
Adding extensions to a course that are specific to an
LD language like IMS LD or Moodle was required, and
later carried out through the use of code tagging which
contain the interface specification of the target language
properties.
For example, Moodle activities have many specific
properties. Using the tagging technique, a Moodle chat
activity permitting users to view past chat sessions can be
described as depicted in Table 3. The @moodle tag defines
the required parameters that are specific to the Moodle
chat, and these are added to the general description of
activity. This definition does not interfere with the basic
structure of the code and furthermore, a generic structure
can be easily transformed into Moodle by adding such
additional markups. The visual language equivalent of this
specification is depicted in Fig. 5.
The IMS LD example in Table 4 is similar to the
previous case, but the definition can be adapted more
precisely to the target EML by using the @imsld tag.
For example, the following tag code defines an IMS LD-
compliant activity-structure of activities, in which only
one of them has to be selected:
@imsld:selection
@imsld:number-to-select 1
composite_activity compositeActivityID {
//General description of the activities
}
The FLEXO language has been specially designed with
the IMS LD standard in mind because of its spread
adoption. Even so, the FLEXO language can hide some
obscurities of the IMS LD specification.
To illustrate this idea, Table 4 shows an example of an
integration of an IMS LD-based unit of learning that includes
a learning-activity associated with a URI, plus a support-
activity to provide instructors with the activity assessment.
Expressing this same example with IMS LD would require
Table 1
Specification of activities and learning flow.
course courseID {
assessment_activity assessmentActivityID {
simple_activity simpleActivityID {
title ‘‘Activity title’’
description ‘‘Activity description’’
resource ‘‘http://y’’
}
assessment {
//Evaluation params
num grade [0,10]
boolean finished
collection scale [‘‘good’’, ‘‘regular’’, ‘‘bad’’]
}
flow:
if(grade 45 && finished) {
then: otherActivity
} else {
flow: anotherActivity
}
}
}
Table 2
Specification of user roles.
course courseID {
roles{
role role1ID extends teacher, learner
role role2ID extends evaluator, learner
}
assessment_activity assessmentActivityID {
simple_activity simpleActivityID {
teacher_role teacher, role1ID
learner_role learner, role1ID
title ‘‘Activity title’’
description ‘‘Activity description’’
resource ‘‘http://y’’
}
assessment {
evaluator_role role2ID
teacher_role teacher, role1ID
//Evaluation params
num grade [0,10]
boolean finished
collection scale [‘‘good’’, ‘‘regular’’, ‘‘bad’’]
}
flow:
if(grade 45 && finished) {
then: otherActivity
} else {
flow: anotherActivity
}
}
}
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346338

Author's personal copy
plenty of level B properties and conditions that might hide
the basic structure and aim of the learning design.
4.2.4. Web-based learning services
An additional requirement of the FLEXO model is to
enable specifying how an external, web-based learning
service can be accessed from a running activity. Learning
services are optional and can be ignored in the core
structure of the course. For that reason, a service interface
definition was added to the FLEXO annotation language,
similar to the language-specific extensions provided for
Moodle and IMS LD. Services are represented by adding
to the core activity description, an annotation with the
@-prefix, having the generic syntax of: @webservice:URI
operation [parameters]. The URI is the identifier of the
service provider object; operation is the requested opera-
tion on the object; and parameters are the set of optional
arguments required for the operation execution.
As a proof-of-concept, the visual authoring environ-
ment integrates support for accessing a web based service
called EvalCOMIX [33], which enables authoring compe-
tence-based assessment instruments, such as rubrics,
assessment lists, and control lists among others. In this
case, the service provider objects are the evaluation
instruments.
The following example is the specification of how a
learning activity is mapped to a ReST-based competence
assessment service that uses the assessment instrument
identified by id to evaluate the activity:
@webservice:evalcomix/assessment/id GET
[type:rubric, description:description]
activity {y}
If the result of executing the HTTP GET request
described is correct, the environment will replace the
specification above with the appropriate query to the web
resource or service that is related to the activity.
The following example depicts how an assessment
rubric is created and linked to an assessment activity. The
rubric definition is coded in XML and encapsulated in the
HTTP POST message body. For example, mapping this
activity to a target language such as IMS LD will generate
a support-activity with a monitor including the imsldcon-
tent elements that have to implement the rubric:
@webservice:evalcomix/rubric/new POST
[type:rubric, id:id, description:description]
@imsld:support_activity
assessment_activity {y}
This way of text-based editing (see Table 5) is more
condensed and expressive than directly editing an XML-
based IMS LD UoL, however it can still be difficult for
some users. Therefore, the visual editor has been
extended to make the integration of web services easier
with the help of visual forms adapted to the service
interface (see Figs. 6 and 7).
5. Evaluation
The FLEXO approach described above has been subject
to an analytic and case study evaluation [34]. The analytic
evaluation has been carried out according to most
representative EML (i.e. IMS LD) and LMS (i.e. Moodle).
Fig. 4. Defining a new set of roles from the default roles for a course.
Table 3
Specification of a Moodle-specific course extension.
course courseID {
assessment_activity assessmentActivityID {
@moodle:chat
@moodle:text ‘‘This is a moodle activity’’
@moodle:visible yes
@moodle:view_past_sessions yes
simple_activity simpleActivityID {
title ‘‘Activity title’’
description ‘‘Activity description’’
resource ‘‘http://y’’
}
assessment {
//Evaluation params
num grade [0,10]
boolean finished
collection scale [‘‘good’’, ‘‘regular’’, ‘‘bad’’]
}
flow:
if(grade 45 && finished) {
then: otherActivity
} else {
flow: anotherActivity
}
}
}
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346 339

Author's personal copy
The case study evaluation is done on an actual LD
experience of a project-based learning course on web
engineering.
5.1. Analytic evaluation
The main objective of the FLEXO language is the
generation of courses ready to run on an LD player or LMS.
Generating the target language required by the run-time
engine is not as simple as integrating concrete function-
alities, since LD languages have their own model and
structure. Although the structure of the FLEXO model can
represent main EMLs and LMS, the final result is not a
one-to-one mapping. We approached the transformation
in two steps: transformation of the core elements of the
target language and transformation of the target lan-
guage-specific extensions. In this section we analyze the
required transformations to deliver first an EML and,
second, an LMS course from the FLEXO model. IMS LD is
selected as the most standardized and extended EML,
while Moodle is selected as the most representative and
widespread open-source LMS.
5.1.1. Core EML elements
Although IMS LD structure and FLEXO language
structure are different, they do share some similarities.
Both structures have activities, role definitions, resources
and a way to express conditions and properties. We can
represent the IMS LD level A elements in FLEXO as a set of
activities linked by flows. The correspondence between
such elements is shown in Table 6. It does not depict all
IMS LD elements, but only those that are readily
generated from core elements of the FLEXO model. Other
IMS LD-specific elements are generated through
@-prefixed annotations, as explained below:
If the user of FLEXO does not model certain required
elements of IMS LD (i.e. play, act, roles, role-parts), the
FLEXO tool generates the following elements by default:
� One play containing one act.
� Two role-parts, one for the teacher and one for the
learner.
� All the properties referenced in the play definition.
Nonetheless, these decisions can be overridden by the
user, as explained below. The IMS LD specification
provides a different role model based on single inheri-
tance, but FLEXO allows defining multiple inheritance
relationships within roles. In the case of roles, the FLEXO
system generates the IMS LD roles that are needed to
fulfill the original role attributions. This is explained in
more detail in the sample course that is later presented as
a case study.
Table 5
Specification of external learning services.
course courseID {
assessment_activity assessmentActivityID {
@webservice:evalcomix/assessment/id GET
[type:rubric, description:description]
simple_activity simpleActivityID {
title ‘‘Activity title’’
description ‘‘Activity description’’
resource ‘‘http://y’’
}
assessment {
//Evaluation params
num grade [0,10]
boolean finished
collection scale [‘‘good’’, ‘‘regular’’, ‘‘bad’’]
}
flow:
if(grade 45 && finished) {
then: otherActivity
} else {
flow: anotherActivity
}
}
}
Fig. 5. Activity properties form to select the kind of Moodle activity.
Table 4
Specification of an IMS LD course extension.
course courseID {
assessment_activity assessmentActivityID {
@imsld:learning_activity
simple_activity simpleActivityID {
title ‘‘Activity title’’
description ‘‘Activity description’’
resource ‘‘http://y’’
}
@imsld:support_activity
assessment {
//Evaluation params
num grade [0,10]
boolean finished
collection scale [‘‘good’’, ‘‘regular’’, ‘‘bad’’]
}
flow:
if(grade 45 && finished) {
then: otherActivity
} else {
flow: anotherActivity
}
}
}
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346340

Author's personal copy
5.1.2. Core LMS elements
Moodle course structure is simpler than the basic
structure of a FLEXO course, lacking conditional flows and
complex evaluations, so on one hand, representing it is
very straightforward. On the other hand, the definition of
roles in FLEXO cannot be mapped directly, because
Moodle courses need user instances to define user groups
and not roles. The correspondence between Moodle core
elements and FLEXO model is shown in Table 7.
The transformation of FLEXO activities to Moodle types of
activities is not considered a core transformation, but carried
out through the LMS-specific extensions described next.
5.1.3. EML- and LMS-specific elements
The EML-specific annotations starting with an @-prefix
(e.g. @moodle, @imsld and so forth) can be combined in
Fig. 6. EvalCOMIX authoring service showing how to edit an assessment rubric.
Fig. 7. Activity properties form used to define the kind of assessment and to access the assessment parameters form, role mapping form and assessment
authoring service.
Table 6
Mapping between IMS LD elements and the FLEXO conceptual model.
IMS LD FLEXO
Play Course
Role Role
Learning-activity SimpleActivity
Activity-structure CompositeActivity
Support-activity Activity
Condition Flow
Property Assessment parameter
Table 7
Mapping between Moodle core elements and the FLEXO conceptual
model.
Moodle FLEXO
Course Course
Topic AssessmentActivity with one activity-structure
Activity SimpleActivity
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346 341

Author's personal copy
the same course specification. Combining them within the
visual authoring environment is not straightforward, how-
ever, because the current editing palette must contain only
those elements of the target language in use. The solution
used to overcome this issue is to ask the user which target
course (i.e. Moodle or IMS LD) he or she wants to edit before
beginning an authoring session, and then to provide them
with an authoring environment specific to the selected
language. If you want to combine attributes pertaining to
another language within the same course, the course has to
be edited in two subsequent sessions and then the
corresponding target for each one selected.
In the visual environment, the values of LMS-specific
extensions can be edited by the user through forms. For
example, Fig. 5 shows the activity properties form used to
select the kind of Moodle activity used to associate the
FLEXO activity.
5.2. Integration of an external assessment service
The FLEXO model and tools enable one to visually edit
web-based services and to describe how these services are
accessed from a given learning activity. Fig. 6 shows how
an assessment rubric can be edited with the EvalCOMIX
competence assessment tool, which is provided as an
external service but integrated within the FLEXO author-
ing tool.
Creating or selecting an assessment instrument that is
available as an external service in FLEXO automatically
configures the EML- or LMS-specific details required to
deploy and run the activity assessment. For instance, if the
course is generated as an IMS LD player, a set of IMS LD
properties are generated to query the service URI about
the assessment rubric. As shown below, the rubric in Fig. 6
is used to evaluate an activity. It can be associated with
any learning activity through the activity properties form
of Fig. 7. When the activity is deployed and run, the
service-based rubric can be seamlessly run and queried
from the activity.
The assessment service must be integrated in an LMS
to be made available for users. For this reason, we have
developed a Moodle extension. When a course that is
edited from FLEXO tools is deployed into Moodle, the
extended EvalCOMIX qualification form of Fig. 8 appears
beside the regular qualification of the Moodle activity. It
can be used to reuse any assessment instrument that has
been previously created with EvalCOMIX.
5.3. Case study on a project-based learning course
The evaluation of the FLEXO LD approach has been
accomplished by the visual design of a complex project-
based learning course on the topic of web engineering.
Fig. 9 depicts the original visual design of the course using
LAMS. It represents the learning flow as a sequence of
software development activities that follow up on an agile
software development method. These activities are inter-
woven with lectures and control assessments. The
preliminaries include a team building phase and a
technology selection activity, in which students can choose
the software development framework they will use
throughout the project. The selection occurs among a
limited number of optional technologies (i.e. Java, Ruby on
rails, .NET and PHP).
Fig. 8. Moodle extension showing the form to select the EvalCOMIX assessment instrument of an activity.
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346342

Author's personal copy
Some LAMS activities are composite, including optional
and branching component activities. For instance, the
technology selection activity defines a LAMS branching
activity that depends on the web development framework
that the team selected (see details in Fig. 10).
The issue of using LAMS visual environment is that
delivered courses must be run on a LAMS server. Thus, we
used the FLEXO tool to visually edit the design of the web
engineering course and then generate it as an IMS LD unit
of learning and as a Moodle course. Fig. 11 depicts the
FLEXO visual design of the web engineering course.
The activities situated in the flow between Study
frameworks and Tech report represent an adaptation that
is equivalent to the Technology selection branching activity
of LAMS. The parameters needed to branch are specified
as assessment properties of the Study frameworks activity,
as depicted in Fig. 12.
In the case of FLEXO, branching is part of the activity
assessment and is used to generate the IMS LD properties
and conditions required to describe the adaptation. This
visual representation of the optional activities keeps the
user from knowing IMS LD level B details.
The FLEXO model enables the definition of multiple
inheritance relationships among roles, which are shown
in Fig. 4 for the web engineering course case study. Since
the project development activities can be subject to
self- and peer-assessment, a set of new roles have been
defined from the basic learner and evaluator roles. This is a
Fig. 9. LAMS editing of a course on web engineering.
Fig. 10. Detail of a branching activity in the LAMS course.
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346 343

Author's personal copy
Fig. 11. FLEXO editing of a course on web engineering.
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346344

Author's personal copy
shorter way of describing the attributions of new roles,
such as self- and peer-evaluator (that inherit the attributions
of learner and evaluator) and consultant (that inherits the
attributions of evaluators). The difference between self-
and peer-evaluator is demonstrated on the basis of the
application of available user roles to each learning
activity. If the peer-evaluator role is applied to an activity,
it will be assessed by a configured set of student peers
from the course. When the self-evaluator role is applied,
the activity will be self-assessed by the student. Since the
IMS LD specification provides a different role model based
on single inheritance, the FLEXO system generates the IMS
LD roles that are needed to fulfill the original role
attributions. For instance, from the role model of Fig. 4,
two IMS LD roles are generated (namely self_evaluator and
peer_evaluator) that inherit and share the attributions of
learner and evaluator; plus the consultant role that inherits
the attributions of evaluator. Furthermore, all the IMS LD
roles that are inherited from evaluators are associated
with the right assessment activities by generating the
appropriate role-part definitions.
6. Conclusion and future work
In this work we have developed a DSL to provide an
abstract and extendible authoring approach to generate
learning designs. A visual representation of the FLEXO
language has been provided using an editing tool that
abstracts the text-based specification of courses. The
FLEXO language delivers the course in a variety of EMLs,
as required by the execution environment or LMS. It hides
most of the technical details from the designer, and can be
easily extended to deliver other formats. The designer
must only be aware of the possibilities of the target
language, but not of how to use them. If the target
platform in which the learning design has to be run is
changed, the course can be generated from the FLEXO
specification with scarce modifications.
The FLEXO model is seamlessly integrated with assess-
ments, which is an inevitable part of learning processes.
Other modeling approaches use add-ons, tools and patterns
to reduce instructors’ knowledge of the IMS LD specification
in their delivered activities; while FLEXO can be combined
with these to further parameterize the activities by defining
assessment parameters and flows that yield adaptive
learning designs. When the activities are deployed externally
to the execution environment, FLEXO provides a learning
service interface that can be used to increase the grain of
interoperability between activities’ specifications and
web-based external applications.
The evaluation has yielded findings that can be related
to the abstraction and extendibility of the approach. First,
the abstract FLEXO representation does not have a one-to-
one mapping of all target languages. This is the reason for
the provision of FLEXO DSL with an attribute-based design
approach that considers IMS LD and Moodle specifics. This
approach is extendible because the core elements of the
language model are so minimal that can be enlarged with
tags from other languages (e.g. LAMS LD) or facilities. For
instance, the design of the ReST-based web service
interface is also grounded on the tag-based extension
mechanism. Nevertheless, users have reported a limita-
tion of the editing tool: it is currently impossible to edit a
course that simultaneously includes annotations for
different languages. Instead, the course must be saved;
then tags removed; course is re-opened as deliverable in
another language, and finally extended with the new
language facilities. This is a limitation of the tool that can
be fixed by defining editing perspectives that ignore
annotations of one or another language.
Further work also includes delivering LAMS sequences,
which have not been included in this version because the
formal LAMS LD language is different than the actual
implementation of sequences in the LAMS player. Never-
theless, we have tested the FLEXO approach on the
Moodle course backup and results show that it is possible
to generate an executable snapshot of the activities of a
learning design ready to be deployed even in the absence
of an LD language.
Acknowledgements
This work has been sponsored by grants from the
FLEXO project (TSI-020301-2008-19) of the Spanish
Avanza programme and from the ASCETA project (P09-
TIC-5230) of the Andalusian PAIDI programme.
References
[1] C. Ferraris, C. Martel, C. Vignollet, LDL for collaborative activities, in:
L. Botturi, S.T. Stubbs (Eds.), Handbook of Visual Languages for
Instructional Design, IGI Global, 2008, pp. 226–253.
Fig. 12. Parameter editing form to define the IMS LD properties that are mapped to branching activities.
J.M. Dodero et al. / Journal of Visual Languages and Computing 21 (2010) 332–346 345