Codeschool in a Box: A Low-Barrier Approach to Packaging

Programming Curricula

Yoshi Malaise

, Evan Cole

and Beat Signer

Web & Information Systems Engineering Lab, Vrije Universiteit Brussel, Pleinlaan 2, 1050 Brussels, Belgium

Keywords:

Curriculum Packaging, Programming Education, Exercise Generation, Smart Learning.

Abstract:

The tech industry is a fast-growing ﬁeld, with many companies facing issues in ﬁnding skilled workers to ﬁll

their open vacancies. At the same time, many people have limited access to the quality education necessary to

enter this job market. To address this issue, various small and often volunteer-run non-proﬁt organisations have

emerged to up-skill capable learners. However, these organisations face tight constraints and many challenges

while trying to design and deliver high-quality education to their learners. In this position paper, we discuss

some of these challenges and present a preliminary version of a curriculum packager addressing some of these

issues. Our proposed solution, inspired by ﬁrst-hand experience in these organisations as well as computing

education research (CER), is based on a combination of micromaterials, study lenses and a companion mobile

application. While our solution is designed for the speciﬁc context of small organisations providing vocational

ICT training, it can also be applied to the broader domain of learning environments facing similar constraints.

1 INTRODUCTION

The tech industry is a fast-growing ﬁeld and accord-

ing to Voka, the Flemish Network of Enterprises,

Belgium is facing a severe shortage of technically

schooled people (Voka, 2019). Belgium is hardly the

only country facing these issues since according to

Statista, the worldwide full-time employment in the

ICT sector is projected to reach 62 million in 2023.

At the same time, many countries are dealing with

large groups of socially vulnerable people with lim-

ited access to the job market. For example, the Bel-

gium federal agency for the reception of asylum seek-

ers (Fedasil) accommodated a total of 31 808 asy-

lum seekers

in January 2023. These conditions

gave rise to multiple initiatives all over the world,

trying to provide up-skilling opportunities to people

with limited access to the labour market by training

them in speciﬁc highly demanded skills in their local

ICT industries. A few examples of such organisations

are HackYourFuture (Denmark, The Netherlands and

Belgium), MigraCode or Girls Who Code.

https://orcid.org/0000-0002-3228-6790

https://orcid.org/0000-0001-8190-0446

https://orcid.org/0000-0001-9916-0837

https://www.statista.com/statistics/1126677/it-

employment-worldwide/

https://www.fedasil.be/en/statistics

Unfortunately, due to the shortage of ICT-skilled

people, there also exists a shortage of career and tech-

nical education teachers capable of teaching these

courses (Devier, 2019). This implies that these or-

ganisations are often run by people with little to no

technical experience, and courses are taught on a vol-

unteer basis by tech professionals who do not neces-

sarily have any pedagogical experience. Furthermore,

these organisations cannot even fall back on open uni-

versity courses as research indicates that universities

are often not addressing all the industry’s speciﬁc

needs (Akdur, 2022) and mainly offering long-form

programmes, making the material a less than ideal ﬁt

for our target audience.

In order for a curriculum packaging solution to

best serve learners, it is vital that the management

is not distracted from operations and the progress of

their learners, and that volunteer mentors can focus on

what they know best; working one-to-one with learn-

ers and preparing examples of well-written code. We

set out to create a solution that makes it easy for vol-

unteers to create materials following educational best

practices. It should further be easy for educational

directors to remix and reuse existing online materi-

als. In this paper, we outline a low-barrier approach to

packaging programming curricula based on our own

experience and inspired by computing education re-

search (CER).

Malaise, Y., Cole, E. and Signer, B.

Codeschool in a Box: A Low-Barrier Approach to Packaging Programming Curricula.

DOI: 10.5220/0011967900003470

In Proceedings of the 15th International Conference on Computer Supported Education (CSEDU 2023) - Volume 1, pages 281-288

ISBN: 978-989-758-641-5; ISSN: 2184-5026

 2023 by SCITEPRESS – Science and Technology Publications, Lda. Under CC license (CC BY-NC-ND 4.0)

281

2 CONTEXT

In order to highlight the novelty and importance of

the work presented in this paper, it is important to

introduce the speciﬁc context in which we want the

proposed tools to operate, how this context might

differ from the traditional university-level courses or

k-12 education that are typically studied by comput-

ing education research, and how existing freely avail-

able resources do not address the needs of vocational

ICT training. Let us start by formulating some key

characteristics of the stakeholders in this context.

The learners in our target audience are typically

people who do not have access to full-time contin-

ued education. They are typically following these up-

skilling classes in combination with a full-time job

and are often also taking care of a family. There-

fore, the presented content should be ﬂexible for asyn-

chronous consumption when it ﬁts within their sched-

ule and they cannot always have the guidance of a

teacher in the room. Having content accessible in

multiple forms that can be accessed in different con-

texts is a major beneﬁt for these learners.

In our context, content creators are well-meaning

software developers who want to contribute to educa-

tion as volunteers by making content in the domain of

their expertise available to the previously-mentioned

learners. These volunteers are a very valuable re-

source as their expertise carries a lot of value to the

learners, but they are frequently not trained as edu-

cators. Often, they also do not have experience with

what makes good educational content and what the

typical progression of students looks like. Therefore,

we want to make sure that they can spend their time

doing what they do best, creating code samples for

the material they want to cover. We then need to in-

clude a system to automatically create exercises of

varying difﬁculty levels about this content so students

can progress naturally. More invested volunteers can

also be a major help if we guide them in the creation

of what good online resources look like. Using this

guidance, they can contribute by developing a small

application instead of directly writing content.

The curriculum designers are typically members

of organisations that want to combine these open ed-

ucation resources into a holistic curriculum covering

enough content to prepare learners to take an entry-

level position in a speciﬁc role, such as a web devel-

oper dealing with in-demand frameworks. The cur-

riculum designers often have limited pedagogical or

technical expertise, and given the fact that they are

likely part of a small non-proﬁt organisation with lim-

ited funding and popular technologies evolve quickly,

they normally do not have the luxury to spend a year

in designing a brand new curriculum. Given these

constraints, it is important for curriculum designers to

ﬁnd adequate resources—often created by the volun-

teer developers mentioned earlier—that can be reused

and repurposed to ﬁt their needs.

Even though these constraints have a major impact

on what kind of material might work and what will

not (precluding many theoretically ideal approaches),

we feel that it is valuable to speciﬁcally target this

challenging context, given that these learners are not

reached by traditional university education, and they

stand to gain the most by switching to a stable job in

the information technology sector. Note that every-

thing that we present can also form an added value

for regular education.

3 SYSTEM COMPONENTS

In the following, we introduce the key components

necessary to properly construct a curriculum for our

target audience. These components consist of a set

of independent online resources focusing on a nar-

row learning objective, while providing immediate

feedback in order for students to practise and im-

prove even when no teacher is nearby, a new way

to explore existing source code in order that students

can learn from pedagogically sound content gener-

ated from samples provided by content creators, and

a mobile companion application that allows students

to practise some exercises in a gamiﬁed environment

while they are on the go and do not have access to a

desktop computer or laptop.

3.1 Micromaterials

In the ﬁeld of education, we have units of learn-

ing materials called learning objects (LO), with each

learning object having well-deﬁned goals on what

they are trying to teach. When authors of these learn-

ing objects take the necessary precautions to ensure

that they can be openly reused by other educators,

these learning objects might be referred to as open

education resources (OER). The 2019 UNESCO def-

inition describes OER as “teaching, learning and re-

search materials that make use of appropriate tools,

such as open licensing, to permit their free reuse, con-

tinuous improvement and repurposing by others for

educational purposes”.

It is clear from this deﬁni-

tion that it is not enough to simply be freely available

to others to be classiﬁed as an OER, but it should be

realistic to incorporate these resources into existing

https://opencontent.org/deﬁnition/

CSEDU 2023 - 15th International Conference on Computer Supported Education

282

larger curricula as educators see ﬁt. The comput-

ing education research ﬁeld has already made great

strides towards not only developing some of these re-

sources, but also making them available to a larger

community. For example, every year authors can sub-

mit nifty assignments that they used in their lectures

to the nifty assignments track of the Technical Sym-

posium of the ACM Special Interest Group on Com-

puter Science Education (SIGCSE) and present them

to their peers. It is important to note that during the

submission process authors have to provide additional

metadata about an assignment, such as the intended

target audience, additional context or its strengths as

well as weaknesses. This additional metadata is of vi-

tal importance for educators who do not simply want

to use existing open education resources as they are,

but possibly repurpose them for their own situations.

After the conference, the artefacts are uploaded to the

nifty assignments page of Stanford University

where

they can be found with all the necessary metadata.

There is a subset of open education resources re-

ferred to as micromaterials, a term coined by Adam

Leskis.

In order for an open education resource to

classify as a micromaterial, there are additional con-

straints that need to be satisﬁed. A micromaterial

should be directly usable by the learner and the mi-

cromaterial should be able to provide automated feed-

back so the learner can improve without additional

oversight by an educator. This way of working is

a perfect match with our target audience of learners

who might be practising at home after a workday. Al-

though it is not a strict requirement to be considered

a micromaterial, many existing micromaterials con-

tain automatically generated content and are mobile

friendly. This provides the user with a virtually end-

less amount of content they can work through until

they grab the concept that they are trying to learn.

In order to further illustrate the idea of a microma-

terial, we provide three examples of micromaterials

that have been developed to be used by our students.

• King’s Scroll. In this browser-based game stu-

dents are shown a randomly generated piece of

JavaScript code that modiﬁes four boolean vari-

ables (helmet, sword, shield and cape) (Malaise

and Signer, 2023). They have to interpret the

piece of JavaScript code and select the hero that

satisﬁes the constraints of these variables at the

end of execution of the code. The micromaterial

is used to help students practise the control ﬂow

of JavaScript programs.

http://nifty.stanford.edu

https://micromaterialsblog.wordpress.com

Figure 1: Screenshot of King’s Scroll micromaterial.

• SQL Study Buddy. This browser-based appli-

cation uses sql.js

(an SQLite version transpiled

to WebAssembly) and allows students to write

queries to be executed in their browser. This helps

to lower the barrier as nothing needs to be in-

stalled locally and students cannot mess up their

database given that it is recreated for every exer-

cise. Students are asked to write SQL queries to

perform certain operations in the online code ed-

itor. Every time a student executes their query,

a set of assertions are run. By looking at which

assertions pass and which fail, students can keep

improving their queries until all checks pass.

• HTML Study Buddy. HTML Study Buddy is a

browser-based application to practise the basics of

HTML markup. Students are presented a screen

that is divided into three parts. In the right part

of the screen, they see a webpage that they have

to recreate. Further, in the left part of the screen,

they are presented jigsaw puzzle pieces based on

Google’s Blockly library. Those jigsaw pieces

contain speciﬁc HTML markup. The available

pieces are determined by the elements used on the

page the students have to recreate, to prevent them

from being overwhelmed. Students can snap the

pieces together in order to construct the webpage.

The webpage resulting from the markup on the as-

sembled jigsaw pieces is updated in the centre of

the screen as soon as a student drags one of the

pieces.

3.2 Study Lenses

As discussed earlier in Section 2, there exists an am-

ple number of online sample projects for nearly every

https://sql.js.org

Codeschool in a Box: A Low-Barrier Approach to Packaging Programming Curricula

283

given topic in programming. Programmers like to

write blog posts about new technologies that they

think are exciting which can also be beneﬁcial for

them to attract new employers. The main issue how-

ever is that these posts are typically not written by

pedagogical experts and the sample code does often-

times not have actionable goals for students to learn

from in a step-by-step manner. This led to the idea of

study lenses.

The concept of study lenses is straightforward; we

want to empower students to be able to learn from any

online code the learner encounters, but still do so in

a pedagogically sound way. In order to achieve this

goal, raw source code is used as input for different

lenses and each lens is used to generate materials for

a speciﬁc learning objective (e.g. reading or tracing).

A wide variety of views are possible and one of the

more basic examples can highlight the code’s syntax

and overlay a canvas to enable students to annotate

and highlight parts of the code. A different lens might

take the code ﬁle, parse it and present the code as a

ﬂowchart to help students focus on the control ﬂow,

or the execution of the program could be visualised

in tools such as PythonTutor

to help student focus

on what goes on in the program’s memory during ex-

ecution. Some micromaterials can also be packaged

as lenses. For example, we have lenses that ask stu-

dents questions about their code or lenses that intro-

duce errors in the code that a student has to ﬁx. The

study lenses environment builds on a plugin-based ar-

chitecture where educators and developers can intro-

duce new lenses on demand.

When designing new lenses, there are a couple of

important constraints to take into consideration. First,

it is important that lenses work on plain code. Any

code should run ﬁne in the target environment and

content creators should not need to change the way

they write the examples to ﬁt the study lenses environ-

ment. Second, lenses should be designed with a “peel

away” principle in mind, where early lenses can pro-

vide a lot of additional context on top of the code, but

the more advanced lenses should do so less and less,

in turn revealing a general-purpose development en-

vironment that matches realistic industry setups. This

way we can satisfy the expertise reversal (Kalyuga

et al., 2009) and the skill transfer (Chiaburu and Mari-

nova, 2005) principles. Finally, lenses should not cre-

ate any platform lock. Content created to be used with

the lenses should not rely on any custom syntax and

the content should still be usable (to some extent) in

a different environment. This is why there is a strong

push towards using open web standards that can be

https://github.com/colevandersWands/study-lenses/

https://pythontutor.com

reused everywhere in addition to regular code ﬁles for

all aspects of curriculum packaging.

The current implementation of study lenses is

available open source and as a Node.js package that

can be installed globally on a student’s system. Stu-

dents can run the study command from any place in

their ﬁle system to explore the current directory in the

study lenses environment. There also exists a study

lenses version that can be embedded into packaged

curricula as described later in Section 4.

3.3 Companion App

The need for mobile learning environments has been

discussed in the past (G

oksu and Atici, 2013) and

its importance has also been highlighted to us during

conversations we had with students of different up-

skilling courses. Many students emphasise the use-

fulness of having access to some material on the go

when they happen to have some time available to en-

gage with content during free time, such as when they

are taking public transportation. Therefore, we im-

plemented an initial prototype of a mobile companion

application; not to replace the study lenses environ-

ment or the online resource, but as an additional way

of consuming content. In order to make the applica-

tion fully portable, we opted for a smartphone appli-

cation that stores its content ofﬂine and thus can be

used even without any cellular connection.

The mobile app has two main functionalities. First

it can be used to view (short) presentations about im-

portant topics as a refresher, which might be useful to

do right before a class or before students start working

on their laptops when getting home. Second the app

also includes small exercises that are generated from

code ﬁles. The app further includes some gamiﬁca-

tion elements such as push notiﬁcations to remind stu-

dents to get their daily practise, and daily goals such

as completing 10 exercises every day. After complet-

ing a certain number of exercises, badges can be un-

locked and shown in the application. Further, exer-

cises are presented according to the Leitner box sys-

tem where exercises that have never been completed

have the highest chance of being selected, and the

more often an exercise has been successfully com-

pleted, the less frequently it is shown. In the following

we list the currently supported types of exercises.

• Parsons Problem. Parsons problems have been

used for a long time in computing education re-

search (Du et al., 2020). When given a Parsons

problem, students receive all the lines of a code

snippet in a shufﬂed form. By dragging and drop-

ping the lines, students need to recreate the orig-

inal code snippet. Whenever a line is placed at

CSEDU 2023 - 15th International Conference on Computer Supported Education

284

the right position, a green checkmark is shown on

that line. This way, users incrementally work on

the problem until they have solved the exercise.

• Comment Slots Exercise. In a comment slots ex-

ercise, a user is presented a snippet of code, but

all the comments have been replaced with combo

boxes. It is up to the student to interpret the code

and match every comment with the corresponding

line of code.

• Parameter Chooser. In a parameter chooser ex-

ercise, users are presented with a function that

takes at least two parameters. However, all oc-

currences of the parameters in the body will be

replaced by combo boxes. By reading and un-

derstanding the surrounding code, it is up to the

learner to infer which of the parameters is used.

• Code Snippet to/from Flowchart. Code Snippet

to/from ﬂowchart exercises present the user with

an original code snippet and three ﬂowcharts. One

of the ﬂowcharts is the correct translation of the

code snippet, the other two are based on slightly

altered versions of the code snippet. It is up to the

user to determine which of the three ﬂowcharts

matches the original snippet. An inverted version

of this exercise is also possible where users re-

ceive one ﬂowchart and three pieces of JavaScript

code.

• Multiple Choice Questions. The multiple choice

question exercises have been inspired by “ques-

tions about learners’ code (QLCs)” (Lehtinen

et al., 2021). In these exercises, the application

analyses a code snippet shown to a student and

asks them questions about the code. Examples of

questions include “What is the name of the func-

tion?”, “Is function X asynchronous?” or “Which

of the following variables are declared in loop ini-

tialisers?”.

4 CURRICULUM PACKAGER

There is a strong need for many organisations to set up

new courses as well as to update existing ones. These

courses could be both long-term formation such as

‘Introduction to Web Development’ over a period of

up to a year, or an advanced follow-up course such

as ‘Reactive Programming’ with a duration of two

months only. It is essential for organisations to be

able to set up these smaller curricula in order to ac-

commodate for the speciﬁc professional needs in their

geographical area.

In recent years, research on how to best pack-

age a curriculum has been conducted by the Curricu-

lum Materials Working Group.

However, their re-

search mainly targets long-form traditional university

courses making use of existing learning managements

systems (LMS). Similar research lead to open stan-

dards such as SCORM,

that allow moving material

between LMS’s. However, such a setup is not a per-

fect ﬁt for our intended use case of ad-hoc volunteers,

working together to come up with a set of open learn-

ing materials. The management of an LMS requires a

substantial effort and the time learners spend on learn-

ing to work with the LMS is time they could have

spent on learning about the concrete content. There-

fore, we strive for our learning environment to be as

close to the industry tools that coaches and learners

will be using throughout their careers. The prelim-

inary version of the packager combines the compo-

nents introduced in the previous section into a holistic

self-contained online curriculum that can be deployed

to any cloud hosting service. Note that our packager

currently supports JavaScript-based curricula, but we

plan to add other programming languages.

In our solution, the source of a curriculum is made

up from a set of folders, with each folder represent-

ing one learning object (e.g. LO

) as illustrated in

Figure 2. Such a learning object can consist of any

type of ﬁles, but the following ﬁles are given a special

meaning during the packaging process:

• Readme.md. The readme.md ﬁle is used to de-

scribe general information about the learning ob-

ject in markdown format. Typically, it is rec-

ommended for the description to list the main

goals of the learning object and to refer to rele-

vant online resources such as videos or blog posts.

We also strongly encourage any learning object

to link to relevant micromaterials using the pro-

vided markdown functionality. Since the system

uses traditional readme ﬁles, the learning objects

can easily be used outside of our environment and

content developers do not need to learn any cus-

tom syntax.

• curriculum.json. The optional

curriculum.json ﬁle contains metadata

for the packager. The name property can be

used to set how the name of the learning object

should appear in the generated curriculum. The

ignoreList property tells the exercise generator

which ﬁles to ignore when generating exercises.

Further, the requires property can be used

to indicate which learning objects should be

completed before the user can partake in this

learning object. The idea for this metadata was

https://cssplice-cm.github.io

https://scorm.com

Codeschool in a Box: A Low-Barrier Approach to Packaging Programming Curricula

285

Source Material

intro.presentation.md

readme.md

code

sample 2

Online Resources

video

blog

micromaterial

links to

package

Study Lenses

Web Server

Presentations

Web Interface

Companion App

Generated Exercises

Packaged Curriculum

publish

requires

code

sample 1

curriculum.json

LOs

Figure 2: Curriculum packager overview.

inspired by Harper-Lite,

a similar system that

strives to make lesson (learning object) discovery

easier by having authors include a harper.yaml

ﬁle in the root directory of each lesson.

• study.json. Optionally, a study.json ﬁle

can be placed in any folder with code samples

(e.g. code sample 1) to conﬁgure the default op-

tions and lenses to be used by the study lenses en-

vironment.

•

.presentation.md. Files with a ﬁlename

*.presentation.md will be interpreted as pre-

sentation ﬁles by the curriculum packager. The

content of the ﬁle should contain valid mark-

down that will be turned into a presentation by the

revealjs

JavaScript library.

•

.js. All JavaScript ﬁles detected in the folder

will be parsed and analysed in order to generate

exercises based on the code. In future versions of

the curriculum packager, we also plan to support

other programming languages.

As we can see from the previous description, there

is no need for curriculum authors to become spe-

cialised in custom tools. Their main work consists

of coming up with realistically looking examples of

the code in action. The markdown ﬁles can easily be

reused in different contexts regardless of what learn-

ing environment is being used. This way we can avoid

a vendor lock-in to our solution. Since all learning

objects are simple folders that can be checked-in to

GitHub, we satisfy all requirements that open learning

objects should have according to the Curriculum Ma-

terials Working Group, namely that we should be able

to create, ﬁx, revise, reuse, share, ﬁnd, track, pull,

push, evaluate and credit open learning materials.

Once the curriculum designers have collected the

learning objects they wish to include in their curricu-

lum, they can run our curriculum packager desktop

application and select all the relevant folders. The

https://third-bit.com/ideas/harper/

https://revealjs.com

packer will then run through these folders and gen-

erate a prepackaged curriculum. The generated cur-

riculum will be a Node.js project using an Express

web server to host all its content. This project can

then easily be deployed online or be made available

on GitHub for students to run it locally. When access-

ing content from the web server, users are presented

with all the learning objects in card form. On these

cards, users can see the content of the readme.md ﬁle.

Further, there are buttons to access the content of the

learning object via the included study lenses server or

to watch any of the presentations on the online slide

presentation screen. At the top of the page there is a

QR code that can be scanned by the companion appli-

cation to download the curriculum’s material (i.e. the

mobile exercises and the presentation) for ofﬂine use.

In a future version of the packager, we are plan-

ning to add support for automatically generating

learning spaces on GitHub based on workﬂows re-

ﬁned over several years of running ICT courses on

GitHub. These would provide a low maintenance al-

ternative to traditional learning management systems.

Organisations willing to run a new class would be able

to specify a list of students, and the system would au-

tomatically generate a GitHub repository where stu-

dents can ﬁnd an outline of their syllabus, indicate

their progress on the Kanban board and post issues if

they get stuck, while using the same tools and work-

ﬂows they will use in their professional career.

5 CHALLENGES AND FUTURE

WORK

Let us now discuss some of the main challenges that

we expect to face when further developing the cur-

riculum packager, as well as some interesting research

directions that we plan to address in the near future.

CSEDU 2023 - 15th International Conference on Computer Supported Education

286

5.1 The Reusability Paradox

Some criticism has arisen from researchers about the

dangers of taking learning concepts out of their origi-

nal context. The claim is that the context itself forms

part of the material to learn, and that material that is so

context agnostic that it can be used anywhere actually

does not provide any real value anywhere (South and

Monson, 2000). This problem has been named the

re-usability paradox and represents one of the main

challenges when building a curriculum out of exist-

ing components and designing the reusable compo-

nents. This is something that one always has to keep

in mind. However, research has shown that there def-

initely is still value in the creation of reusable com-

ponents in education as long as effort is done to ﬁnd

the right balance between de-contextualisation and

usefulness (Wiley et al., 2004). This means that we

should not go overboard by reducing the size of the in-

dividual topics and that it is okay that some individual

objects still cover more than strictly one topic (Bart

et al., 2019). A rule of thumb proposed by Wiley

is that we should ask ourselves “Can you imagine

wanting to teach some portion of this topic without

teaching the other parts?”. If the answer is no, all

the subtopics belong to one learning object. We be-

lieve there is still room to construct a set of guide-

lines on the scoping of learning objects that can be

shared with other researchers interested in designing

reusable learning objects.

5.2 Automatic Exercise Generation

A future direction we wish to further explore are

other ways to automatically generate exercises based

on codebases. Ideally, these exercises should cover

all aspects of the PRIMM (Predict-Run-Investigate-

Modify-Make) principle (Sentance et al., 2019) to en-

sure that students can improve step by step over the

given codebase. In our current implementation, all

exercise generation is done by parsing the JavaScript

ﬁles using Acorn

and analysing the abstract syntax

tree. We are convinced that this technique can be

used to generate even more interesting exercises be-

sides the ones we are generating today. Apart from

this method, we are also looking into other ways to

generate exercises based on machine learning. Inter-

esting research towards automatic exercise generation

based on the code-trained Natural Language Model

Codex presented by OpenAI (Chen et al., 2021) has

recently been presented at ICER (Sarsa et al., 2022).

This is deﬁnitely another promising direction that we

are planning to further investigate.

https://github.com/acornjs/acorn

5.3 More Ways to Look at Code

We will keep advancing the study lenses platform and

search for interesting and useful new lenses that could

beneﬁt our learners. We feel like the concept of using

existing ﬁles as a basis and providing students differ-

ent ways of interacting with and analysing these ﬁles,

is an interesting concept to further explore. The ver-

satility of the study lenses and the additional content

they provide out of the box—as long as there is some

example code given in a domain—leads to a great

amount of new content for learners to take in with a

small time investment needed by content creators.

In its current form, the study lenses implementa-

tion works as a web environment, which is great given

the ﬂexibility and ease-of-use this provides. We are

further investigating what it could look like to have

the plug-in-based study lenses concept incorporated

into existing Integrated Development Environments

(IDEs). This would not only allow students to ben-

eﬁt from the layers of interactivity and perspectives

on top of the code right where they are already work-

ing but it would also allow the students to take this

environment with them and use those tools to help

them understand work related code as they graduate

towards their ﬁrst internships.

5.4 Knowledge and Content Modelling

In recent years, there has been a push towards the

use of knowledge graphs in education. A knowledge

graph is a formal way to describe all the topics and

their relations that are covered within a ﬁeld of ed-

ucation. The topics are represented as nodes, while

the directed edges indicate which topics are prerequi-

sites of other topics (Rizun, 2019). This representa-

tion allows for automated reasoning and might enable

future intelligent tutoring systems. In past work, the

knowledge graph representation has been used to ﬁnd

ways on how to model students’ progression (Ilkou

and Signer, 2020), as well as to build recommenda-

tion engines suggesting only exercises in a learner’s

zone of proximal development, both in traditional ed-

ucation (Baker et al., 2020) as well as in sports edu-

cation (Malaise and Signer, 2022).

We are planning to further investigate the use of

student modelling to adapt the content to the learn-

ers. This modelling will consist of two parts. First,

we will model the learners’ constraints and prefer-

ences (i.e. “What devices do they have access to?”

or “Can they study for long sessions or do they typ-

ically have multiple short sessions?”). Second, we

will also use personal knowledge graphs to model

the progression of individual learners throughout the

Codeschool in a Box: A Low-Barrier Approach to Packaging Programming Curricula

287

global knowledge graph. Based on this additional in-

formation, we would like to introduce an intelligent

tutoring system in order to better recommend exer-

cises to the students. One can, for instance, imag-

ine that the application does not simply show exer-

cises based on the Leitner box system, but makes

informed suggestions based on a student’s past per-

formance for speciﬁc individual skills. It might fur-

ther be used to detect a user’s knowledge gaps. In

this domain, the EduCOR ontology

could be a good

ﬁt, as it models both the education side of things but

also incorporates the mapping to labour-market skills.

Recently, GraphBRAIN has been used to power an

initial implementation of an intelligent tutoring sys-

tem (Ferilli et al., 2022). GraphBRAIN allows users

to utilise ontologies as database schema on top of a

graph database. Exploring the direction of having our

model conceptualised as an ontology (in combination

with EduCOR) is a promising direction as it means

that all generated data could easily be shared across

systems with other projects in the ﬁeld of computing

education research.

6 CONCLUSION

In this position paper we presented a number of

challenges and constraints faced by small organisa-

tions offering professional training and up-skilling for

learners who are not served by traditional education.

We introduced a preliminary version of a curriculum

packager combining micromaterials, study lenses and

a companion mobile app to address some of these

challenges. It is important to note that most of the

content designed to work in the presented context and

its constraints will also be usable in general contin-

ued education. We further discussed some remaining

challenges and future research directions. The pro-

posed research is essential for reaching under-served

learners and to expand the body of knowledge in com-

puting education research.

REFERENCES

Akdur, D. (2022). Analysis of Software Engineering Skills

Gap in the Industry. ACM TOCE.

Baker, R. et al. (2020). The Results of Implementing Zone

of Proximal Development on Learning Outcomes. In

Proc. of EDM 2020.

Bart, A. C., Hilton, M., Edmison, B., and Conrad, P. (2019).

The Problem of Packaging Curricular Materials. In

Proc. of SIGCSE 2019.

https://tibonto.github.io/educor/

Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. d. O.,

et al. (2021). Evaluating Large Language Models

Trained on Code. arXiv.

Chiaburu, D. S. and Marinova, S. V. (2005). What Predicts

Skill Transfer? An Exploratory Study of Goal Orien-

tation, Training Self-Efﬁcacy and Organizational Sup-

ports. International Journal of Training and Develop-

ment, 9(2).

Devier, B. H. (2019). Teacher Shortage and Alternative Li-

censure Solutions for Technical Educators. The Jour-

nal of Technology Studies, 45(2).

Du, Y., Luxton-Reilly, A., and Denny, P. (2020). A Review

of Research on Parsons Problems. In Proc. of ACE

2020.

Ferilli, S., Redavid, D., Di Pierro, D., and Loop, L. (2022).

An Ontology-driven Architecture for Intelligent Tu-

toring Systems with an Application to Learning Ob-

ject Recommendation. IJCISIM, 14.

oksu,

I. and Atici, B. (2013). Need for Mobile Learn-

ing: Technologies and Opportunities. Procedia - So-

cial and Behavioral Sciences, 103.

Ilkou, E. and Signer, B. (2020). A Technology-enhanced

Smart Learning Environment Based on the Combina-

tion of Knowledge Graphs and Learning Paths. In

Proc. of CSEDU 2020.

Kalyuga, S., Ayres, P., Chandler, P., and Sweller, J. (2009).

The Expertise Reversal Effect. Educational Psychol-

ogist, 38(1).

Lehtinen, T., Santos, A. L., and Sorva, J. (2021). Let’s

Ask Students About Their Programs, Automatically.

In Proc. of ICPC 2021.

Malaise, Y. and Signer, B. (2022). Personalised Learning

Environments Based on Knowledge Graphs and the

Zone of Proximal Development. In Proc. of CSEDU

2022.

Malaise, Y. and Signer, B. (2023). King’s Scroll: An Ed-

ucational Game to Practise Code Prediction. In Proc.

of SIGCSE 2023.

Rizun, M. (2019). Knowledge Graph Application in Educa-

tion: A Literature Review. Folia Oeconomica, 3(342).

Sarsa, S., Denny, P., Hellas, A., and Leinonen, J. (2022).

Automatic Generation of Programming Exercises and

Code Explanations Using Large Language Models. In

Proc. of ICER 2022.

Sentance, S., Waite, J., and Kallia, M. (2019). Teaching

Computer Programming With PRIMM: A Sociocul-

tural Perspective. Computer Science Education, 29(2-

3).

South, J. B. and Monson, D. W. (2000). A University-

wide System for Creating, Capturing, and Delivering

Learning Objects. The Instructional Use of Learning

Objects.

Voka (2019). Voka: “The Shortage of Technical Proﬁles is

Threatening to Become the Achilles’ Heel of Innova-

tion in Flanders”. Stanley Milton.

Wiley, D., Waters, S., Dawson, D., Lambert, B., Barclay,

M., Wade, D., and Nelson, L. (2004). Overcoming the

Limitations of Learning Objects. JEMH, 13(4).

CSEDU 2023 - 15th International Conference on Computer Supported Education

288