1em.

UNIVERSITÀ DI PISA
DEPARTMENT OF COMPUTER SCIENCE
BSc in Computer Science

Adaptive and Gamified Learning Paths
with Polyglot and .NET Interactive

by

Tommaso Martorella

supervisors

Dr. Antonio Bucchiarone

Prof. Rossano Venturini

ACADEMIC YEAR 2021/2022

###### Acknowledgements

First and foremost, I’m extremely grateful to my supervisor Antonio
Bucchiarone, whose invaluable experience, constructive advice, and profound
belief in my abilities made this work possible. I’d also like to extend my
gratitude to the entire Fondazione Bruno Kessler for this incredible
internship opportunity. Special thanks to Diego Colombo for introducing me to
Antonio and for his irreplaceable insight, guidance, and support throughout my
entire journey. To conclude, I cannot forget to thank my family and friends
for all the unconditional support in this very intense academic year.

###### Abstract

The digital age is changing the role of educators and pushing for a paradigm
shift in the education system as a whole. Growing demand for general and
specialized education inside and outside classrooms is at the heart of this
rising trend. In modern, heterogeneous learning environments, the one-size-
fits-all approach is proven to be fundamentally flawed. Individualization
through adaptivity is, therefore, crucial to nurture individual potential and
address accessibility needs and neurodiversity. By formalizing a learning
framework that takes into account all these different aspects, we aim to
define and implement an open, content-agnostic, and extensible platform to
design and consume adaptive and gamified learning experiences.

###### Contents

  1. 1 Introduction
    1. 1.1 The education revolution
      1. 1.1.1 Learning
      2. 1.1.2 Teaching
    2. 1.2 Existing technology
    3. 1.3 Thesis objectives and structure
  2. 2 Formalization
    1. 2.1 The planning domain
    2. 2.2 Learning fragments
      1. 2.2.1 Motivating scenario
      2. 2.2.2 Towards more complete learning fragments
      3. 2.2.3 Formal framework
    3. 2.3 Gamified learning paths and activities
    4. 2.4 Summary
  3. 3 Technology
    1. 3.1 POLYGLOT
    2. 3.2 .NET Interactive
      1. 3.2.1 Journey
    3. 3.3 Interactive notebooks & Amazon Alexa
      1. 3.3.1 Interactive notebooks
      2. 3.3.2 Alexa
  4. 4 Implementation
    1. 4.1 Architecture overview
    2. 4.2 Teacher design tool
      1. 4.2.1 The drawing area
      2. 4.2.2 The properties panel
      3. 4.2.3 PolyglotElement processing
      4. 4.2.4 Adding node and edge types
    3. 4.3 Execution engine
      1. 4.3.1 The conversion process
    4. 4.4 Other components
      1. 4.4.1 Backend
      2. 4.4.2 Alexa adapter
  5. 5 Conclusions and Future Directions

## 1\. Introduction

######

Adaptive learning is the delivery of personalized learning experiences that
address an individual’s unique needs instead of a one-size-fits-all approach.
It may be achieved through just-in-time feedback, personalized learning paths,
ad-hoc resources, or another wide array of techniques. But why is it
important?

###  1.1 The education revolution

######

Education is universally recognized as one of the factors with the highest
impact on society and the individual. The United Nations included education in
their 2030 Agenda for Sustainable
Development111https://www.un.org/sustainabledevelopment/education/. UNESCO
launched the Global Education
Coalition222https://en.unesco.org/covid19/educationresponse/globalcoalition in
response to the COVID-19 pandemic. The European Union created the Digital
Education Action Plan (2021-2027)333https://education.ec.europa.eu/focus-
topics/digital-education/digital-education-action-plan to foster and support
the adaptation of educational systems in the digital age. This collective
global effort is motivated by a continuously increasing technology
availability and a rising global enrolment rate. Furthermore, according to
UNESCO, higher education is the fastest-growing sector444Data from UNESCO [1]
and Statista (retrieved on 29 June 2022).
https://www.statista.com/statistics/1226999/net-enrollment-rate-in-primary-
school-worldwide/ and https://www.statista.com/statistics/1227022/net-
enrollment-rate-in-secondary-school-worldwide/ , with its global enrolment
rate doubled in the last twenty years [1].

######

Rising trends such as flexible learning pathways and micro-credentials555
https://education.ec.europa.eu/education-levels/higher-education/micro-
credentials tend towards more versatile forms of content delivery and
credential recognition to accommodate the increasing demand for specializing
training, especially in the labour market. In this regard, a recent study by
the International Institute for Educational Planning (UNESCO IIEP) shows that
there are fewer pathways for students to prepare for transitioning to the
labour market than for entering and progressing through higher
education666https://unesdoc.unesco.org/ark:/48223/pf0000381545/PDF/381545eng.pdf.multi.

####  1.1.1 Learning

######

Among the various aspects that comprise the education field, learning is the
one that requires the most careful treatment. The inherently complex domain
lends itself to a wide range of forms and means, each with its techniques and
quirks. Learning may happen at home, at work, or even on the go; thus, it is
not limited to the classroom only nor confined to formal settings in general.
Learning activities can (and should be) tailored around the individual. This
personalization process is critical when targeting
neurodiverse777https://en.wikipedia.org/wiki/Neurodiversity profiles or
students with accessibility needs. Not only is content’s form fundamental, but
delivery and additional aids are required to make a learning experience
impactful.

######

Educational resources are the primary means to help (and sometimes assess)
students in their learning journey. They can be of various kinds such as
videos, interactive tutorials, pdf texts, images, podcasts and many others.
Platforms such as Google Classroom888https://edu.google.com/workspace-for-
education/classroom/, Microsoft Teams999https://www.microsoft.com/en-
us/microsoft-teams/group-chat-software, or custom
Moodle101010https://moodle.org/ deployments are common ways to deliver content
in formal educational settings, but YouTube111111https://www.youtube.com/,
Wikipedia121212https://en.wikipedia.org/wiki/Wikipedia, and platforms like
Udemy131313https://www.udemy.com/ can reach a broader audience in informal
environments. Furthermore, the increasing availability of Open Educational
Resources (OER)141414Open Educational Resources are public domain or open
licensed educational resources https://www.unesco.org/en/communication-
information/open-solutions/open-educational-resources can help reduce
teachers’ material preparation and lower the accessibility barrier in terms of
cost and material kind.

######

Learning is also crucial in the industry. The continuous technological
disruptures are creating job positions in brand new
fields151515https://www.linkedin.com/business/talent/blog/talent-
strategy/linkedin-most-in-demand-hard-and-soft-skills. Entirely new hard
skills are required to fit the openings. Moreover, soft skills are among the
most sought-after skills because of their lower trainability and a slower
changing pace161616https://www.linkedin.com/business/talent/blog/talent-
acquisition/why-shell-pushes-hard-on-soft-skills. However, the offer seldom
matches the demand. This mismatch led to the need for upskilling and
reskilling. The former means teaching employees new, advanced and valuable
skills to match the profile required for the next step in their current career
path. The latter, instead, targets employees with a profile similar to the one
required. It consists in teaching them adjacent skills and training them for
their new, different job. Both of them are fundamental learning activities
that take place in varied (and often dissimilar) environments.

######

The design of a learning experience should take into account all of these
different factors. On the other hand, a design framework should not make
assumptions about content type, form, delivery, and validation while still
removing any obstacle between the teacher, the student, the environment, and
the learning experience.

####  1.1.2 Teaching

######

From a student’s perspective, effective teaching means 1-1 coaching. It allows
teachers to target specific misunderstandings and necessities with real-time
feedback and explanations relevant to the student’s experiences. On the other
end of the spectrum, the most teacher-effective approach is the one-to-many
lecture, where the teacher prepares the material upfront for being presented
to a wide audience. One of this approach’s main downsides is encouraging
passive learning. A study by K.R. Koedinger et al. shows that the "Doer
Effect" is a causal association between practice and learning outcomes and
that practising is six times more effective than reading [2]. Another
significant drawback lies in the motivational aspect. Active learning is more
effective in learning outcomes and motivation than passive learning [3].
Despite that, a recent article on PNAS by L. Deslauriers et al. highlights a
negative correlation between actual learning and the feeling of learning in
the students [4]. However, gamification and serious games gained consensus as
tools to motivate people to engage in beneficial activities, even if seen as
unrewarding or tedious [5].

######

Individual coaching is rarely feasible due to poor scalability, whilst one-to-
many general training is scalable but lacks individualization altogether.
Adaptive learning combines the benefits of individualized delivery and
manageability by leveraging software personalization, while gamification can
be used to enhance motivation through personalized rewards or cooperative and
competitive activities.

###  1.2 Existing technology

######

Adaptive learning technologies have gained traction over the last decade.
Existing solutions have been successful in both domain-specific [6] and
institution-wise implementations. In 2015, the Colorado Technical University
(CTU) reported that, following their Intellipath™ adoption, the course pass
rate rose sharply by 27%, and the average grade and retention rate were also
significantly affected. CogBooks171717https://www.cogbooks.com/ conducted a
pilot study with Arizona State University (ASU), resulting in findings similar
to CTU.

######

SmartSparrow181818https://www.smartsparrow.com/ (recently acquired by the
industry-leading Pearson) provides a user-friendly WYSIWYG content authoring
tool to create interactive online experiences. Realizeit, Cerego and CogBooks
create content for their adaptive platforms by partnering with institutions
like ASU, the American Psychological Association, or directly with industrial
partners and customers. Each platform also provides in-depth analytics on the
students’ performance, errors, time spent learning, and other related metrics.
Those solutions solve the problem of individualization and verticality of
linear learning paths but overlook a fundamental factor: familiarity with the
tools and the environment. Job candidates in software engineering, for
example, are expected to be somewhat comfortable with industry-leading tools
and methodologies. Therefore, not only delivering interactive exercises
directly on those tools enables richer experiences but also better prepares
the students for their future. High school electronics students, instead, may
benefit from hands-on experience with physical devices like
Arduinos191919https://www.arduino.cc/. Moreover, integrating education-ready
tools like pi-top kits202020pi-top produces high-quality educational kits for
electronics and robotics based on the Raspberry Pi. https://www.pi-top.com/
allows access to already existing quality resources.

######

Novel interactive learning experiences can emerge even with the use of
available technologies. Augmented and virtual reality are still emerging, but
education and industry are already taking advantage of their benefits [7]. In
the classroom, they are used to promote interactivity and generate engagement.
In the industry, they found use in, among the others, remote maintenance on
industrial devices, surgery training programs, aviation, and even military
equipment212121Since 2019 Microsoft and the US Army have collaborated on using
HoloLens to enhance soldiers’ situational awareness
https://news.microsoft.com/transform/u-s-army-to-use-hololens-technology-in-
high-tech-headsets-for-soldiers/. Similarly, the use of voice user interfaces
(like virtual assistants) may be a means to mimic a study companion that can
ask questions, give feedback and help with misunderstandings. Adaptive
educational technology should allow and encourage the creation of these varied
activities to prepare the students for dynamic and changing environments where
learning and adaptability are essential.

###  1.3 Thesis objectives and structure

The main focus of current implementations of adaptive learning technologies is
the content personalization engine. However, although being a crucial
component of adaptive experiences, the delivery of said personalized content
happens through a custom-designed student platform. That may be a good fit for
some activities, but it is a limiting factor for others, such as those in the
aforementioned examples. This document aims to provide an open, content-
agnostic, and extensible framework to enable the design and consumption of
adaptive and gamified learning experiences. To achieve that, it is necessary
to define beforehand what learning pathways are, what are they composed of,
and how can they be personalized (Chapter 2). Afterwards, in section 2.3, we
will address how gamification is linked to adaptivity and its crucial role in
learning pathways. After an excursus on the used technologies in chapter 3,
chapter 4 will describe the proposed architecture, the motivations behind the
critical choices from both a teacher’s and a student’s perspective, its
implementation, and how it can be extended to include new tools for the
teacher and delivery mediums for the student. Lastly, the closing chapter will
include a glimpse into future directions and possibilities enabled by the
proposed solution.

## 2\. Formalization

######

A learning path111https://en.wikipedia.org/wiki/Learning_pathway is a route a
learner takes through the domain of learning activities that allows them to
build knowledge progressively. Learning path designers create them to help
students move from an initial competency set toward a goal competency set via
a fixed sequence of activities. They are usually tailored to the average
student; therefore, they do not fit the majority of learners by design222TED
Talk by Todd Rose (former professor at Harvard and founder of the Laboratory
for the Science of Individuality) https://www.youtube.com/watch?v=4eBmyttcfU4.
An effective learning path is a student-specific program that helps them move
from their initial competency set to their goal competency set via a flexible
sequence of activities that considers individual strengths and
weaknesses333https://en.wikipedia.org/wiki/Individual_Learning_Plan. The
remainder of this chapter will describe how the generation of a suitable
learning path can be formulated as a planning
problem444https://en.wikipedia.org/wiki/Automated_planning_and_scheduling in
the domain of learning activities.

###  2.1 The planning domain

######

Durand et al. propose a model to build a learning design recommendation system
based on graph theory using cliques [8]. Similarly, we want to formulate a
hypergraph in terms of competencies and learning activities. Although the
literature does not agree on the term "competency", the definition
"Competencies are skills, knowledge, and capabilities that individuals should
have possessed when completing assigned tasks or achieving the goals",
proposed by Chung & Lo in 2007, serves our purpose. Learning activities are
activities designed to create the conditions for
learning555https://newlearningonline.com/learning-by-design/glossary/learning-
activity. They correspond to the "when completing assigned tasks or achieving
the goals" part of the competencies definition. In other words, learning
activities link competencies in terms of "prerequisites" and "effects".
Therefore, we see competencies as vertices and learning activities as directed
hyperedges connecting the competencies required to those that should be
obtained upon completing the activity. Figure 2.1 (a) shows a hypergraph
modelling a simple domain composed of competencies (1..7) and activities
(A..E).

((a))

((b))

((c))

Figure 2.1: Figure (a) shows an example domain hypergraph. Given the initial
competency set {1, 2, 5} and goal {6}, figures (b) and (c) show two different
admissible learning paths777Images based on
https://mathematica.stackexchange.com/a/58758.

A simplistic initial formulation may be:

> Student competencies are defined by the set
> $C_{stud}=\\{c_{1},c_{2},...,c_{n}\\}$
>
> A learning activity $a=(a_{pre},a_{post})$ is an action that can be taken
> iff $a_{pre}\subseteq C_{stud}$ and results in the new $C_{stud}$ to be
> $C_{stud}\cup a_{post}$
>
> A goal is a set of competencies $G=\\{c_{1},c_{2},...,c_{n}\\}$
>
> A learning path is a sequence of learning activities
> $S=\\{a_{1},a_{2},...,a_{n}\\}$ such that, given a goal $G$
>
> $G\subseteq C_{stud}\cup\bigcup_{j=1}^{n}a_{jpost}\land\forall
> i\in[1..n]:a_{ipre}\in C_{stud}\cup\bigcup_{j=1}^{i-1}a_{jpost}$

######

Although correct, this first definition exemplified in figure 2.1 does not
consider any other factor than the domain itself (that only includes
competencies and activities). Furthermore, the planning domain may evolve and
even change, the student’s behaviour is dynamic and partially observable, and
the result of the student’s actions is uncertain. Planning should also
consider that the student may alternate different activities or acquire
competencies in other ways. Because learning activities aim to create the
conditions for learning, and those conditions are different for each
individual, their effect is not even guaranteed.

######

Instead, following the approach proposed by Bucchiarone et al. [9], planning
in a dynamic system relies on a learning model (or context model) composed of
learning properties, each describing an aspect of the system (e.g. student
competencies, …). A learning context captures the status of all learning
properties. The status of each learning property can evolve naturally through
learning fragments or unpredictably through external changes (e.g. obtaining a
certificate or an award).

###  2.2 Learning fragments

######

Learning fragments are a structured composition of learning activities. They
are a more realistic representation of an educational process that can include
complex flows of other activities. Fragments behave like regular learning
activities: they have prerequisites which limit their applicability and
effects that can influence the learning context. The following sections will
further detail fragments, their creation, and their application with the help
of a motivating scenario.

####  2.2.1 Motivating scenario

######

The chosen scenario is part of an introductory statistics course that fits a
broader data science program. Its goal is for the student to understand the
concepts of average, median, and the difference between them. In other words,
the students should have obtained those competencies when completing the
fragment.

######

We have identified four kinds of concrete learning activities needed to define
the scenario:

  * •

lessons

  * •

close-ended questions

  * •

quizzes

  * •

coding activities

######

Each concrete activity serves a different educational purpose. Lessons are
activities that should augment the student’s knowledge and understanding of a
topic. Closed-ended questions are short assignments to get students to apply
the concepts learned in lessons immediately and gauge their initial
understanding. Quizzes follow a review lesson and verify if the student is
ready to move to the next topic. Lastly, coding activities occur at the end of
the fragment to solidify theoretical knowledge and gain hands-on experience on
the topic.

######

We want students to first learn about the average, then the median, and then
how to code them. We also want students to understand the average, the median,
and the difference between them, so the fragment includes a review lesson and
an additional quiz in case the student fails the close-ended question. Once
the student has completed the "average" section, they move to the median,
where they will face the same pattern for recovery used for the average.
Suppose that the closed-ended question requires the student to calculate the
median. Since understanding the difference is part of the goal, if the student
answers with the average value instead of the median, they should be given a
particular review lesson that highlights the differences instead of a regular
review lesson. All those different alternative paths merge before the coding
activities. While the other exercises have a known correct answer, coding
activities do not. Furthermore, to be considered correct, a program may not
only be required to have a correct output (e.g. through unit tests) but also
to have some properties on the source code itself (e.g. low cyclomatic
complexity888https://en.wikipedia.org/wiki/Cyclomatic_complexity or proper
encapsulation999https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))
or on its execution (e.g. time or memory constraints). For the sake of
simplicity, the transitions in this scenario’s coding activity only include
"pass" and "fail" without further specifying the criteria. However, as
evidenced by the previous example, fragments must not pose any limit on the
relationship between inner activities. The complete fragment diagram appears
in figure 2.2.

Figure 2.2: A learning fragment for an introductory statistics course

####  2.2.2 Towards more complete learning fragments

######

As described in section 2.2.1, fragments are self-contained structured
activities, but sometimes educators do not need to be specific when assigning
exercises or activities. Suppose a teacher wants students to train on self-
balancing binary search trees to cement their knowledge better. Any chosen
exercise (or structured activity/learning fragment) would fit the task as long
as they satisfy specific properties, such as being about the assigned topic
and being in the same difficulty category. This scenario leads to the need to
be able to define activities abstractly.

##### Abstract Learning Activities

######

"An abstract learning activity is defined at design time in terms of the goal
it needs to achieve, expressed as learning context configurations to be
reached, and is automatically refined at run time into an executable learning
path, considering the set of available fragments, the current learning
context, and the learning goal to be reached" [9].

######

The refinement process aims to automatically compose available fragments to
fulfil the goal of the abstract activity, given the current context
configuration. Abstract activities may also contain other abstract activities,
so further refinements may be required.

######

This approach’s advantage is twofold: thanks to runtime refinement, teachers
can spend less time focusing on irrelevant details, while students can benefit
from a more accurate personalization. During the refinement process, abstract
activities can be replaced with the best fragment according to the most up-to-
date student profile, his understanding of the topic, and available
educational resources. For example, students with attention deficit
hyperactivity disorder (ADHD) may benefit from consuming fragments composed of
bite-sized activities instead of activities that require long-lasting
concentration so they can take more frequent
breaks101010https://www.verywellmind.com/help-for-students-with-adhd-20538
[10]. Similarly, those who have shown more significant gains when exposed to
video resources (i.e. instead of textual resources) may benefit from being
suggested videos more often than others.

######

Furthermore, runtime refinement facilitates the reuse and enhances the
updatbility of existing content. Fragments can be as specific as the one
proposed in the scenario and as complex and abstract as a course syllabus or
even an entire academic degree programme. A course outline may still be valid
and relevant, even when educational resources are being updated, new fragments
are added, or existing ones are changed. Likewise, specific fragments and
activities can be reused (if still appropriate) when the course outline is
modified, i.e. when topics are added/removed, or their order is changed.

####  2.2.3 Formal framework

##### Learning Properties

######

Every learning property is modelled with a learning property diagram: a state-
transition system capturing all possible property values and value changes,
each labeled with the corresponding event.

######

A learning property diagram is a tuple $c=\langle L,L_{0},E,T\rangle$, where:

  * •

$L$ is a set of learning states and $L_{0}\subseteq L$ is a set of initial
states;

  * •

$E=E_{unc}\cup E_{cnt}$ is a set of learning events, where $E_{unc}$ is a set
of uncontrollable and $E_{cnt}$ is a set of controllable events, such that
$E_{cnt}\cap E_{unc}=\emptyset$;

  * •

$T\subseteq L\times E\times L$ is a transition relation.

$L(c)$, $E(c)$, etc. indicate the corresponding elements of $c$.

######

A learning context $C$ is defined as a set of individual learning property
diagrams; thus, a space of learning context configurations is defined as
$L=\prod_{c\in C}L(c)$ and the set of controllable events is
$E_{cnt}=\bigcup_{c\in C}E_{cnt}(c)$ .

##### Learning Fragments

######

A learning fragment is a tuple $l=\langle S,S_{0},A,T,\textit{Ann}\rangle$,
where:

  * •

$S$ is a set of states and $S_{0}\subseteq S$ is a set of initial states;

  * •

$A=A_{con}\cup A_{abs}$ is a set of activities, where $A_{con}$ is a set of
concrete activities and $A_{abs}$ is a set of abstract activities. $A_{con}$,
and $A_{abs}$ are disjoint sets;

  * •

$T\subseteq S\times A\times S$ is a transition relation;

  * •

$\textit{Ann}=\langle\textit{Pre},\textit{Eff},\textit{Goal}\rangle$ is a
process annotation, where Pre is the precondition labelling function that
links $A_{con}$ to the learning properties, Eff is the effect labelling
function that links $A_{con}$ to the controllable events that contribute to
mutating the learning properties, and Goal is the goal labelling function that
links $A_{abs}$ with its goal state.

##### Learning Configuration

######

A learning configuration is a tuple
$\Lambda=\langle\mathcal{I},\mathcal{F}\rangle$ where:

  * •

$\mathcal{I}\in L(c_{1})\times\ldots\times L(c_{n}),c_{i}\in C$ is the current
configuration of learning property diagrams;

  * •

$\mathcal{F}$ is the set of available learning fragments.

$\mathcal{I}(\Lambda)$, $\mathcal{F}(\Lambda)$ indicate the corresponding
elements of a configuration $\Lambda$.

##### Goal

######

Goals are not simply states $l\in L$ to be reached (“reachability goals”), but
also conditions on the whole plan execution paths (“extended goals"). A goal
$\mathcal{G}$ is satisfied when the current learning configuration $\Lambda$
is such that $\mathcal{I}(\Lambda)\models\mathcal{G}$ and the execution plan
used to reach the configuration satisfies the extended conditions [11].

##### Refinement

######

An adaptation problem is generically defined as a tuple
$\xi=\langle\Lambda,\mathcal{G}\rangle$, where $\Lambda$ is the current
learning configuration and $\mathcal{G}$ is an adaptation goal over $C$.

######

$\Lambda(\xi)$ and $\mathcal{G}(\xi)$ indicate the corresponding elements of a
problem $\xi$.

######

Refinement is a particular kind of adaptation mechanism used when $a$ is an
abstract activity. It means solving an adaptation problem $\xi$ where
$\mathcal{G}(\xi)=\textit{Goal}(a)$. $\Lambda^{\prime}$ is obtained from
$\Lambda$ using the new refined fragment.

##### Planning

Figure 2.3: The planning process needs a goal and the learning properties and
fragments in their STS form

######

A planning domain is derived from adaptation problem $\xi$ that aims to
achieve an adaptation goal. In particular, a set of $n$ learning fragments
($f_{1},\dots,f_{n}\in\mathcal{F}(\Lambda)$) and a set of $m$ learning
property diagrams ($c_{1},\dots,c_{m}\in C$) are transformed into state
transition systems (STS) using transformation rules similar to those presented
in [11]. The planning domain $\Sigma$ is obtained as the product of the STSs
$\Sigma_{f_{1}}$ …$\Sigma_{f_{n}}$ and $\Sigma_{c_{1}}$ …$\Sigma_{c_{m}}$,
where STSs for fragments are synchronized on preconditions and effects.

$\Sigma=\Sigma_{l_{1}}\|\dots\|\Sigma_{l_{n}}\leavevmode\nobreak\
\|\leavevmode\nobreak\ \Sigma_{c_{1}}\|\dots\|\Sigma_{c_{m}}$

The initial state $r$ of the planning domain is derived from the current
configuration $\mathcal{I}(\Lambda)$, by interpreting it as states of the STSs
defining the planning domain. Similarly, the learning goal $\mathcal{G}(\xi)$
is transformed into a planning goal $\rho$ by interpreting the configurations
in $\mathcal{G}(\xi)$ as states in the planning domain. Once everything has
been transformed, the planner generates a plan $\Sigma_{c}$ that needs to be
transformed back into its executable form. The process is illustrated in
figure 2.3

######

For further reading on the topic, see "Dynamic Adaptation of Fragment-based
and Context-aware Business Processes" and "Incremental Composition for
Adaptive by-Design Service Based Systems" by Bucchiarone et al. [9][12].

###  2.3 Gamified learning paths and activities

######

Gamification is the strategic attempt to enhance systems, services,
organizations, and activities by creating similar experiences to those
experienced when playing games in order to motivate and engage
users111111https://en.wikipedia.org/wiki/Gamification. Gamified applications
are increasingly popular: Duolingo121212https://www.duolingo.com/ uses
gamification to teach languages, and Apple
Fitness131313https://en.wikipedia.org/wiki/Fitness_(Apple) encourages its
users to "close" the daily activity rings by including badges, challenges, and
competitions. Minecraft Education141414https://education.minecraft.net/ takes
the opposite approach, with the base game being enriched with educational
tools to exploit its popularity (with significant results [13]). Location-
based games have been used to promote personal hygiene and social distancing
to limit the COVID-19 spreading [14]. In the domain of software engineering,
POLYGLOT explores the application of gamification mechanisms to mixed
modelling and programming exercises [15].

######

Designing a gamified tool is not only adding points and badges. It means
creating a game narrative that guides players through increasingly complex
challenges, keeping them engaged with social activities such as group work or
competitions. It means providing immediate feedback (as expected from a game-
like environment) and students taking autonomous choices to progress down the
individually decided path. Gamification is not an add-on. Instead,
gamification mechanisms are fundamental to the learning path personalization
process in two ways. Not only they do keep the students engaged, but they can
also be used as tools to gain insight into the student’s behaviour from a
different perspective and thus help generate a more personalized and engaging
learning path.

######

We define gamification properties (such as points or badges), gamification
fragments, and engagement configuration $\Gamma$ analogously to the
corresponding learning properties, learning fragments, and learning
configuration. We can therefore use the same planning technique to generate
the engagement path associated with a specific learning path.

######

A system $\mathcal{S}$ can then be defined as a tuple
$\mathcal{S}=\langle\Lambda,\Gamma\rangle$ and its evolution, which involves
both the learning configuration and the engagement configuration, is a
function
$\mathcal{E}:\langle\Lambda,\Gamma\rangle\rightarrow\langle\Lambda^{\prime},\Gamma^{\prime}\rangle$.
Those two subsystems are not independent: gamification mechanisms influence
the evolution of the learning system (e.g. by "unlocking" an activity when a
certain point threshold is reached) and the learning configuration influence
the adaptation of gamification mechanisms (i.e. the required number of points
necessary to "unlock" the activity). This is necessary because, in order to
increase engagement, the gamification mechanisms must be calibrated according
to the underlying activities.

######

If we were to plot engagement versus learning effectiveness, we would aim to
keep the students in the upper right corner of the plot. Both gamification
mechanisms and learning activites influence both metrics. No matter what
gamification mechanisms are in place, if a student fails several exercises in
a row and does not see any chance of success or no trace of progression, they
would surely get demotivated. Likewise, if gamification mechanisms were to
reward easy exercises too much, the student would still have a reasonably high
engagement, but their learning quality would surely diminish by not engaging
in challenging activities. By influencing each other during their evolution,
the learning system and the engagement system would be able to maintain the
correct balance.

((a))

((b))

((c))

Figure 2.4: Different results of the runtime refinement

For example, given the fragment shown in figure 2.4 (a), the runtime
refinement phase could produce a result similar to 2.4 (b) or 2.4 (c),
depending on the learning context configuration (i.e. the student’s profile).
If we wanted to promote collaboration amongst peers, a reward for engaging in
an optional collaborative activity might be a reasonable solution. However,
the reward would need to be adjusted based on the number of mandatory and
optional collaborative activities and their duration and difficulty.
Similarly, to encourage a more effective learning process, if the student were
to engage only in a narrow range of activities (e.g. quizzes), he should be
prompted with choices that make appear the other options more appealing than
their current path. The goal is to guide the student in their active choice to
engage in more challenging and fruitful activities instead of making them
mandatory and lowering their engagement.

###  2.4 Summary

######

A learning path aims to guide the student in their journey from their initial
competency set towards their goal through learning activities. Each activity
has a set of prerequisites and effects. Fragments are complex structured
activities. They can be designed for specific purposes such as clearing
misunderstandings, challenging the best students, and addressing
neurodiversity and accessibility needs. During the planning phase, fragments
are composed according to the student’s characteristics (learning context) to
satisfy a given goal. During runtime refinement, abstract activities are
replaced with available fragments to fulfil their design-time goal. Deeply
integrated gamification mechanisms enhance engagement and give guidance for a
more suitable personalization.

## 3\. Technology

###  3.1 POLYGLOT

######

POLYGLOT is a research project on adaptive and gamified education led by Dr
Bucchiarone at Fondazione Bruno Kessler. Initial work on mixed modelling and
programming exercises [15] has been part of the MODELS 2021
conference111https://conf.researchr.org/details/models-2021/models-2021-technical-
papers/30/POLYGLOT-for-Gamified-Education-Mixing-Modelling-and-Programming-
Exercises and BETT 2022222https://uk.bettshow.com/. Despite the initial effort
in the software engineering domain, the project aims to encompass education in
a broader sense and create a common ground to build novel educational
experiences. To achieve that, current work on POLYGLOT comprehends three main
areas:

  * •

Generalization of learning activities and metamodelling.

  * •

Student and teacher usability, including the definition of the learning path
and different mediums to consume it.

  * •

Adaptivity and feedback to address individual needs.

######

The initial prototype was heavily notebook-centric and focused on programming
with C#. It aimed to create exercises that teach students basic programming
concepts (like classes) through incremental small steps guided by timely
feedback (a demo video is available at
https://www.youtube.com/watch?v=sxsHy2PbH8E). The validation of student
submissions not only used runtime tests but also included custom
Roslyn333Roslyn is the .NET Compiler Platform and provides useful APIs to
build custom code analysis tools https://github.com/dotnet/roslyn static
analyzers. The project then evolved and began to integrate other languages. In
particular, we ported SysML v2444https://www.omgsysml.org/SysML-2.htm to .NET
Interactive (more about the porting in the next section) and included it in
incremental exercises formed by a design and an implementation phase in the
same notebook. All prototypes have gamification elements powered by FBK’s
Gamification
Engine555https://github.com/smartcommunitylab/smartcampus.gamification, a
rule-based gamification platform that enables the definition of
Drools666https://www.drools.org/ rules governing the evolution of the game
elements.

######

Figure 3.1: SysML v2 exercise with rich output, gamification, and feedback

Additional information on POLYGLOT and its development can be found on GitHub
at https://github.com/polyglot-edu.

###  3.2 .NET Interactive

######

.NET interactive777https://github.com/dotnet/interactive is a group of CLI
tools and APIs that enable users to create interactive
experiences888https://devblogs.microsoft.com/dotnet/net-interactive-is-here-
net-notebooks-preview-2/. It provides several essential functionalities for
building learning experiences, such as:

  * •

Rich output support with MIME types and
formatters999https://github.com/dotnet/interactive/blob/main/docs/formatting.md.

  * •

Multi-language support and interoperability (e.g. via variable sharing
101010https://github.com/dotnet/interactive/blob/main/docs/variable-
sharing.md).

  * •

Loading NuGet packages at runtime.

Figure 3.2: .NET Interactive rich and interactive output

######

In general, the .NET Interactive execution model revolves around the concept
of kernels: an abstraction of a component that accepts commands and produces
output. Existing ones support several programming languages (e.g. C#, F#, and
JavaScript), query languages (e.g. SQL), markup languages (e.g. Markdown and
HTML), and others are being explored (e.g. Python). However, kernels are not
limited to programming. For example, an
NLP111111https://en.wikipedia.org/wiki/Natural_language_processing kernel
could evaluate student solutions, answer their questions, and provide
additional insights via images, audio, video, or interactive content (Figure
3.2).

Figure 3.3: .NET Interactive architecture overview
diagram131313https://github.com/dotnet/interactive/blob/main/docs/kernels-
overview.md

######

.NET Interactive’s command-
event141414https://en.wikipedia.org/wiki/Command_pattern modular architecture
(see figure 3.3) is perfectly suitable to support our extensibility needs in
several different ways:

  * •

We have successfully managed to port SysML v2 to .NET Interactive by wrapping
its official kernel151515https://github.com/Systems-Modeling/SysML-v2-Pilot-
Implementation for Jupyter161616https://jupyter.org/ with a lightweight
compatibility layer. Since the original kernel is written in Java, it runs on
the JVM in a separate process and communicates with .NET Interactive via JSON-
RPC transparently from the user’s perspective.

  * •

Before moving to Journey, we built POLYGLOT using a custom
middleware171717https://github.com/dotnet/interactive/blob/main/docs/kernels-
overview.md#middleware to intercept code submissions, run code analyzers,
capture the produced events (such as the returned value), and provide custom
magic
commands181818https://github.com/dotnet/interactive/blob/main/docs/magic-
commands.md in the context of mixed modelling and programming exercises [15].

  * •

Following the philosophy of versatile delivery introduced in chapter 1, we
have been experimenting with Amazon
Alexa191919https://en.wikipedia.org/wiki/Amazon_Alexa as a frontend for
learning activities such as lessons and quizzes.

####  3.2.1 Journey

######

Journey202020https://github.com/dotnet/interactive/tree/main/src/Microsoft.DotNet.Interactive.Journey
is an open-source library, now part of the main .NET Interactive product, that
enables the creation of open-ended interactive learning experiences. It is
based on a few simple concepts:

  * •

A lesson is a logical equivalent to an exercise or a group of exercises. Setup
and cleanup code can be defined, for example, to load libraries or data for
the student transparently. A lesson is composed of challenges that are not
limited in number or sequence.

  * •

A challenge represents a step of an exercise. Challenges capture events
produced by the kernels and memorize the submission history. Each challenge
has its own customizable rules to perform validation tasks. Like lessons,
challenges can have setup code, but they can also have post-submission code to
perform arbitrary tasks (e.g. drawing a chart with the data filtered by the
student) and to decide what challenge to execute next based on the
submission’s and rules’ results.

  * •

A rule represents a characteristic about the student’s answer to be verified.
It has a piece of code to perform validation tasks and decide if the student’s
submission satisfies the required property or not. Rules do not only represent
mandatory characteristics; they can also represent additional desired
properties that may differentiate a good answer from a great one. Each rule
either fails with customized feedback or succeeds with a message.

###  3.3 Interactive notebooks & Amazon Alexa

####  3.3.1 Interactive notebooks

######

"The idea of a notebook is to have an interactive document that freely mixes
code, results, graphics, text and everything
else"212121https://writings.stephenwolfram.com/2016/09/how-to-teach-
computational-thinking/ (Steven Wolfram). Most notebooks implementations are
usually web-based applications and take advantage of web technologies to
provide that flexibility and portability. Notebook documents are composed of
cells that contain code snippets and produce output (or multiple outputs) and
can execute independently of one another. These programming tools are already
widespread in computational-based domains like data science but are gaining
traction in education to support a wide variety of pedagogical
scenarios222222https://www.epfl.ch/education/educational-initiatives/jupyter-
notebooks-for-education/teaching-and-learning-with-jupyter-notebooks/.

######

.NET Interactive integrates seamlessly with notebook environments like Jupyter
and VS Code. Those notebook environments send commands to the .NET Interactive
composite kernel13 and react to the produced events and output. However, VS
Code also exposes a notebook kernel that can receive commands and produce
events. This addition enables a deeply integrated interaction with the editor.
Journey uses this peculiarity to create cells dynamically as the student
progresses through challenges. Thus, the resulting experience is not defined a
priori but built incrementally and revealed to the student only when needed so
that learners are not flooded with information at the beginning and can better
focus on relevant content.

####  3.3.2 Alexa

######

Alexa232323https://developer.amazon.com/en-US/alexa is a virtual assistant
made by Amazon, capable of carrying out various automated tasks like
controlling smart home devices or providing real-time information on sports or
news. Users can interact with Alexa via a voice-based conversational user
interface that third-party services can extend through apps called "skills".

Figure 3.4: Alexa request flow252525Image from
https://trailhead.salesforce.com/en/content/learn/modules/alexa-development-
basics/get-started-with-alexa

######

When a user invokes Alexa by saying the wake word (i.e. "Alexa") followed by a
sentence, the device sends the captured audio, called utterance, to the cloud.
Developers provide a number of sample utterances to help Alexa map invocation
to intents. There, speech recognition models and natural language
understanding techniques are used to route the request to the correct intent
handler registered by a skill. Intent handlers then process the created intent
and produce a response that may be textual or/and video (for those devices
that support it). Last, a text-to-speech engine transforms the response and
speaks it to the user.

## 4\. Implementation

###  4.1 Architecture overview

######

As stated previously, the project aims to provide an open, content-agnostic
and extensible framework for designing and consuming adaptive and gamified
learning experiences. We imagine a student experience entirely tailored to
their needs and choices. For example, we think students should be able to do
some lessons and quizzes with Alexa, switch to VS Code to do some coding
activities, and then move to another frontend to do something else, all
without friction. That is why we exploit the flexibility of .NET Interactive
in POLYGLOT’s execution engine. Students’ interactions with external tools
occur through Adapters that bind actions on the student frontend to .NET
Interactive commands and bind .NET Interactive events to a supported output
(e.g. audio for Alexa) with custom formatters.

Figure 4.1: POLYGLOT architectural overview

######

The word "adaptive" in adaptive learning paths means being able to adjust the
students’ needs, like assigning exercises based on their previous responses or
the capabilities of the platform they are on. This adaptation is allowed by
the collaboration between the Execution Engine and the Backend. The former
handles the students’ submissions and validates their responses, while the
latter uses the results of the validation phase to assign the next activity in
the learning path.

######

The two most important aspects of an educational platform are simplicity in
the content creation process and content availability to students for
consumption and teachers for reuse. Designing and realizing learning fragments
for such a variegated learning experience might seem a daunting task at first.
That is why POLYGLOT includes a Learning Path Editor heavily focused on the
teachers’ experience. Its visual-editing capabilities and integration with the
rest of the platform allow the creation of ready-to-use learning fragments
with ease, thanks to the abstractions provided.

######

The Gamification Engine and the AI Planner are already working with internal
prototypes. However, they have not yet been integrated even though the
architecture is ready.

###  4.2 Teacher design tool

Figure 4.2: Teacher design tool for learning fragments

######

The teacher design tool, shown in figure 4.2, is a visual editor for learning
fragments (as described in section 2.2). It aims to simplify the creation of
said fragments by providing useful abstractions and powerful composition
tools. The UI comprises two main elements: the drawing area and the properties
panel. The drawing area is the core of the visual editing experience. Nodes
can be added, connected, and rearranged with simple clicks or drag-and-drop
interactions. Nodes and edges themselves can be interactive components that
augment the visual editing experience. The properties panel, instead, provides
fine-tuning tools to define the activities and the links between them.

######

To define the learning fragment, a teacher can create new activities with a
right-click on the canvas, change their type and parameters from the
properties panel, and connect them together by dragging from the handle on the
source node to the handle on the destination node. By clicking on an edge, the
teacher can edit the link condition by choosing from a list of existing
abstractions or by writing their own validation code.

######

The tool is implemented using web technologies with
React111https://reactjs.org/ and TypeScript222https://www.typescriptlang.org/
with a particular focus on flexibility and extensibility. Its design allows it
to be part of a more comprehensive learning management tool. The drawing area
and the properties panel are different abstract views that operate on the same
data differently. Both components manipulate the same PolyglotElements (i.e.
nodes and edges) by working on the shared state via Zustand333Zustand is a
lightweight, unopinionated state-management library for React
https://github.com/pmndrs/zustand actions (see figure 4.3).

Figure 4.3: Teacher design tool architecture overview

####  4.2.1 The drawing area

######

The drawing area builds its functionalities upon
ReactFlow444https://reactflow.dev/, a React library for building node-based
editors and interactive diagrams. As mentioned previously, nodes are
interactive components themselves, personalizable in style and functionalities
through custom ReactFlowNode component implementations (the node UI component
in ReactFlow), as already happens for existing nodes (see figure 4.4 for a
sample implementation). Handles555https://reactflow.dev/docs/api/nodes/handle/
are the component responsible for validating and accepting connections between
nodes (more about validation in the future works section). Connecting two
nodes creates a new ReactFlowEdge: a customizable interactive component not
significantly different from the ReactFlowNode.

Figure 4.4: ReactFlowNode component for the multiple choice question node

######

ReactFlowNodes and ReactFlowEdges are one of the three components that define
a PolyglotNode or PolyglotEdge. They may display some properties relative to
their respective node or edge, so they might depend on a portion of the shared
state and should be updated and re-rendered when the dependency changes.
However, those components are not just consumers: even simple actions like
moving a node or creating a connection modify the state, and those changes
should be reflected everywhere they are needed.

####  4.2.2 The properties panel

######

The properties panel is the primary configuration tool for all
PolyglotElements, including the fragment itself. Regardless of their type, all
nodes share a set of fundamental characteristics and the same holds for edges.
The properties component, therefore, contains two subcomponents: one for
nodes’ general properties and the other for type-specific ones. The same
subdivision happens for edges. When the user selection changes, the sidebar is
automatically updated and filled with both subcomponents according to the
selected element (i.e. node or edge) and its type.

Figure 4.5: Properties component for the multiple choice question node

######

Maintaining a consistent state is necessary to ensure the correctness of the
existing elements and their relationships. On the contrary, allowing arbitrary
operations on the state is also necessary to provide flexibility and
extensibility. Zustand adopts an immutable state
model666https://en.wikipedia.org/wiki/Immutable_object where actions are not
allowed to modify the state directly, but a copy must be created first. This
approach has significant advantages but adds boilerplate to those actions that
modify the state, thus increasing the error margin if done by hand. However,
updates are made trivial by combining customized composable type-safe input
handlers and the use of Immer777https://immerjs.github.io/immer/ (a package to
work with immutable objects conveniently) to create strongly typed
PartialDeep888A Partial type is a type whose properties are all made optional.
A PartialDeep type extends the concept of Partial by recursively making
optional the properties inside nested objects. For further information check:
https://github.com/sindresorhus/type-
fest/blob/79f6b6239b270abc1c1cd20812a00baeb7f9fb57/source/partial-
deep.d.ts#L36 updates that will be deeply merged into the existing state with
the exposed actions. The result of this approach is present in figure 4.5 on
lines 7-16, 28 and 32.

####  4.2.3 PolyglotElement processing

######

The teacher design tool tries to achieve two opposite goals: providing useful
abstraction to allow teachers to define the fragments naturally while
remaining concrete enough to allow students to consume them without further
intervention. This dual goal is especially challenging to achieve with edges
where existing types allow teachers to define links abstractly with clauses
such as "pass" or "fail", but, as explained in section 2.2.1, not all
activities are suitable for that abstract condition. Activities and
connections must then undergo a programmable transformation phase to be
converted into their executable counterparts. Implementation details can be
generated behind the scenes to bridge the gap between the abstract world of
activities and connections and its concrete executable form. Furthermore, some
needed values may depend on the combination of others, so generating them
guarantees consistency. For example, edges correspond to Journey rules in the
execution phase. This correspondence is achieved by generating the validation
code in this transformation phase. Figure 4.6 shows an example transformation
to generate additional node attributes.

Figure 4.6: Multiple choice question node type

####  4.2.4 Adding node and edge types

######

The whole architecture and the individual components have been carefully
designed to minimize the knowledge and expertise needed to extend the
platform. Developers can easily create additional custom nodes and edges just
by adding two (or optionally three) components:

  * •

A node (or edge) type that extends the base PolyglotNode type or every other
preexisting subtype (figure 4.6).

  * •

A NodeProperties (or EdgeProperties) component for the properties panel to
edit type-specific data (figure 4.5).

  * •

An optional ReactFlowNode (or ReactFlowEdge) to customize the appearance and
functionalities in the drawing area (figure 4.4).

Those are virtually the only components needed in the entire POLYGLOT
architecture to add custom activities. .NET Interactive formatters can further
customize the appearance of such activities in students’ frontends. The source
code is available on GitHub at https://github.com/polyglot-edu/node-editor.

###  4.3 Execution engine

Figure 4.7: POLYGLOT execution engine lifecycle

######

This component constitutes the core of the student experience. It is
responsible for handling user interactions and validating students’
submissions. Its straightforward lifecycle (figure 4.7) is designed to exploit
Journey’s strengths by using it in a semi-controlled fashion. When the
assigned activity and its outgoing edges are retrieved from the backend, they
undergo a transformation phase where the activity is converted into a Journey
challenge and edges into Journey rules. This process is essential because it
allows running the validation code mentioned in section 4.2.3. Once converted,
the challenge is ready to be launched. First, the setup code gets executed,
and then the activity is "shown" to the student in their frontend, thanks to
.NET Interactive formatters. When the active frontend adapter produces an
event, Journey intercepts it and runs the registered rules against the student
submission. POLYGLOT then sends the result of this validation phase back to
the backend that will use this additional knowledge to suggest the next
suitable activity.

####  4.3.1 The conversion process

######

Abstractly, a connection between two activities means that if a property on
the source activity is satisfied, the student is allowed to pass to the
destination activity. This process needs three components to work correctly:

  * •

information on the source activity

  * •

information on the student submission

  * •

information on what property to enforce and how to do it

######

Suppose a quiz activity has an outgoing edge that enforces the property
"pass". In this context, "pass" means that the student’s answer must be among
the correct solutions to the exercise. If we were to translate it into code,
we would write a function that takes three inputs (the components mentioned
above) and returns a boolean representing the validation result.

Figure 4.8: Pass/Fail abstract condition implementation

######

The actual code (figure 4.8) is not too far from the previous description. It
takes a PolyglotValidationContext as input and returns a pair (result,
feedback). The PolyglotValidationContext type contains the three essential
components:

  * •

a Journey RuleContext that holds information on the student submission

  * •

an Exercise that contains information on the source activity

  * •

and a Condition that contains information on the edge (e.g. if the condition
is pass or fail)

######

C# is a compiled language, so the condition code must be compiled at runtime
with the CSharpScript API999The scripting APIs enable .NET applications to
instatiate a C# engine and execute code snippets against host-supplied
objects.
https://github.com/dotnet/roslyn/blob/daab8026f666f07fb43aef9126a98e9968a355b6/docs/wiki/Scripting-
API-Samples.md before Journey can use it in rules. C# is also a statically
typed language; thus, the deserialization of Exercise and Condition requires
their type to be known in advance. Given our extensibility goal, we overcome
this limitation using DLR’s101010DLR is .NET’s Dynamic Language Runtime
https://docs.microsoft.com/en-us/dotnet/framework/reflection-and-
codedom/dynamic-language-runtime-overview ExpandoObject111111An ExpandoObject
represents an object whose members can be dymanically modified at runtime
https://docs.microsoft.com/en-
us/dotnet/api/system.dynamic.expandoobject?view=net-6.0
https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_Converters_ExpandoObjectConverter.htm
to deserialize the exercise and the condition data into a dynamically typed
variable121212https://docs.microsoft.com/en-us/dotnet/csharp/programming-
guide/types/using-type-dynamic. This method allows us to run arbitrary
activities (even newly created ones) without needing the execution engine to
know their existence.

######

The execution engine is available as a NuGet package along with the SysML
kernel and various C# and SysML analyzers. The source code is available on
GitHub at https://github.com/polyglot-edu/runtime.

###  4.4 Other components

####  4.4.1 Backend

######

At the moment, the backend is not a significantly complex component. Its main
task is to support the teacher’s design tool and the execution engine by
providing RESTful APIs to operate on the learning fragments. It is implemented
with TypeScript and Express131313https://expressjs.com/, and the source code
is available on GitHub at https://github.com/polyglot-edu/backend.

####  4.4.2 Alexa adapter

######

The Alexa integration with POLYGLOT is composed of two major components: the
Alexa skill and an ASP.NET server hosted on Azure. As explained in section
3.3.2, Alexa transforms utterances into custom-defined intents. Our intent
handler sends the content of the intent
slot141414https://developer.amazon.com/en-US/docs/alexa/custom-skills/create-
the-interaction-model-for-your-skill.html#intents-and-slots to the ASP.NET
server. Once there, the user request is converted into a SubmitCode command,
sent to the appropriate kernel, and executed as expected by .NET Interactive,
Journey and POLYGLOT’s execution engine. The events produced are sent back to
Alexa, which reads their content to the user.

Figure 4.9: Simplified implementation of Alexa’s intent handler

## 5\. Conclusions and
Future Directions

######

Adaptive education still remains an open research topic at the intersection of
several different domains like cognitive sciences and informatics. We have
identified some directions to explore in future collaborations:

  * •

Abstract activities are at the core of our formalization. Extending POLYGLOT
to include them is our highest priority. To do that, we need to include them
in the editor, design a tool for defining goals, and integrate the AI planner
to include the runtime refinement and harness the power of abstract
activities. We are already working on all these tasks with the help of another
intern at FBK.

  * •

Runtime refinement is one of the most powerful concepts in the entire
framework. However, it is most effective only if there is a substantial amount
of fragments to choose from. We think that creating an open fragment database
would benefit students (with better refinement and high-quality educational
content) and teachers who can focus on the big picture and let the platform
adjust the details.

  * •

To further extend the previous point, leveraging open educational resources
with NLP techniques for automatic content annotation would significantly
contribute to the database. This task is one of the main goals of Project
Encore111https://grial.usal.es/encore, an ERASMUS+ project that involves
multiple universities and companies.

  * •

Allowing students to use arbitrary frontends for their tasks is indeed
challenging. This support is still experimental and needs more work to ensure
the quality of the learning experience. Furthermore, not all frontends are
suitable for all kinds of tasks: for example, using Alexa to do a coding
exercise might not be the best idea. We need to further define what "suitable"
means and implement something similar to a content negotiation mechanism.

  * •

To easily define the fragments, POLYGLOT provides some basic abstractions for
connections such as "Pass/Fail". As explained previously, this abstraction may
be correct for some exercises but not applicable to others. We want to further
explore this topic to enhance the correctness of existing fragments, validate
connections to prevent the creation of erroneous links, and define other
composable abstractions.

  * •

We plan to add support for existing learning management
systems222https://en.wikipedia.org/wiki/Learning_management_system (e.g.
Moodle LMS) in the same modular fashion as we are doing with students’
frontends. This extension would allow incremental integration of parts of
POLYGLOT within existing learning infrastructures and increase the adoption of
adaptive learning technologies.

  * •

The combined evolution of the engagement and learning systems described in
section 2.3 is still an open research problem. Gamification mechanisms are
effective only when they fit the learning path perfectly. Usually, it is the
gamification designer’s duty to design the game narrative and the other game
elements to achieve that fit. However, the power of adaptive learning paths
comes from the runtime refinement; therefore, paths are not available upfront.
The engagement system must then evolve through an automatic calibration phase
to the mechanisms to the underlying activities.

  * •

The learning path planning is crucial for effective refinement. We aim to
enhance the planner by leveraging machine learning techniques using learners’
behavioural data. Our goal is to improve contextual activity suggestions (and
hopefully feedback), considering non-standard parameters like the capabilities
of the interface the student is using.

######

## References

  * [1] U. IIEP, “Sdg 4 - policies for flexible learning pathways in higher education: taking stock of good practices internationally,” 2020.  https://unesdoc.unesco.org/ark:/48223/pf0000372817.locale=en.
  * [2] K. R. Koedinger, E. A. McLaughlin, J. Z. Jia, and N. L. Bier, “Is the doer effect a causal relationship? how can we tell and why it’s important,” in Proceedings of the Sixth International Conference on Learning Analytics & Knowledge, LAK ’16, (New York, NY, USA), p. 388–397, Association for Computing Machinery, 2016.  https://doi.org/10.1145/2883851.2883957.
  * [3] C. A. Benware and E. L. Deci, “Quality of learning with an active versus passive motivational set,” American Educational Research Journal, vol. 21, no. 4, pp. 755–765, 1984.  https://doi.org/10.3102/00028312021004755.
  * [4] L. Deslauriers, L. S. McCarty, K. Miller, K. Callaghan, and G. Kestin, “Measuring actual learning versus feeling of learning in response to being actively engaged in the classroom,” Proceedings of the National Academy of Sciences, vol. 116, no. 39, pp. 19251–19257, 2019.  https://doi.org/10.1073/pnas.1821936116.
  * [5] A. Bucchiarone, A. Cicchetti, N. Bencomo, E. Loria, and A. Marconi, “Gamified and self-adaptive applications for the common good: Research challenges ahead,” in 2021 International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS), pp. 149–155, 2021.  https://doi.org/10.1109/SEAMS51251.2021.00028.
  * [6] B. G. Prusty and C. Russell, “Engaging students in learning threshold concepts in engineering mechanics: adaptive elearning tutorials,” in 17th International Conference on Engineering Education (ICEE), pp. 21–26, 2011.  https://www.ineer.org/Events/ICEE2011/papers/icee2011_submission_250.pdf.
  * [7] N. Elmqaddem, “Augmented reality and virtual reality in education. myth or reality?,” International Journal of Emerging Technologies in Learning (iJET), vol. 14, no. 03, p. 234–242, 2019.  https://doi.org/10.3991/ijet.v14i03.9289.
  * [8] G. Durand, N. Belacel, and F. LaPlante, “Graph theory based model for learning path recommendation,” Information Sciences, vol. 251, pp. 10–21, 2013\.  https://doi.org/10.1016/j.ins.2013.04.017.
  * [9] A. Bucchiarone, A. Marconi, M. Pistore, and H. Raik, “Dynamic adaptation of fragment-based and context-aware business processes,” 2012 IEEE 19th International Conference on Web Services, pp. 33–41, 2012.  https://doi.org/10.1109/ICWS.2012.56.
  * [10] D. Ougrin, S. Chatterton, and R. Banarsee, “Attention deficit hyperactivity disorder (adhd): review for primary care clinicians,” London Journal of Primary Care, vol. 3, no. 1, pp. 45–51, 2010.  https://doi.org/10.1080/17571472.2010.11493296.
  * [11] U. D. Lago, M. Pistore, and P. Traverso, “Planning with a language for extended goals,” in Eighteenth National Conference on Artificial Intelligence, (USA), p. 447–454, American Association for Artificial Intelligence, 2002.
  * [12] A. Bucchiarone, M. De Sanctis, A. Marconi, M. Pistore, and P. Traverso, “Incremental composition for adaptive by-design service based systems,” 2016 IEEE International Conference on Web Services (ICWS), pp. 236–243, 2016.  https://doi.org/10.1109/ICWS.2016.38.
  * [13] T. Karsenti, J. Bugmann, and P. P. Gros, “Transforming education with minecraft? results of an exploratory study conducted with 118 elementary-school students,” 2017.  https://education.minecraft.net/content/dam/education-edition/software-downloads/Minecraft_Research_Report_Karsenti-Bugmann_2017.pdf.
  * [14] D. Chen, A. Bucchiarone, and Z. Lv, “Meetdurian: Can location-based games be used to improve covid-19 hygiene habits?,” Games and Culture, vol. 17, no. 5, pp. 679–702, 2022.  https://doi.org/10.1177/15554120211049578.
  * [15] A. Bucchiarone, T. Martorella, D. Colombo, A. Cicchetti, and A. Marconi, “Polyglot for gamified education: Mixing modelling and programming exercises,” 2021 ACM/IEEE International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C), pp. 605–609, 2021.  https://doi.org/10.1109/MODELS-C53483.2021.00092.