Programming Learning Support Methods based on Adaptive

Programming Learning SupportMethods based on AdaptiveHypermedia and Program

Visualization

Yu Yan

A DISSERTATION

SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS

FOR THE DEGREE OF DOCTOR OF PHILOSOPHY

IN COMPUTER SCIENCE AND ENGINEERING

Computer Networks Laboratory

Graduate Department of Computer and Information Systems

University of Aizu, Japan

March 2018

ii

Copyright by Yu Yan

All Rights Reserved

iii

The thesis titled

Programming Learning Support Methods based onAdaptive Hypermedia and Program Visualization

by

Yu Yan

is reviewed and approved by:

University of Aizu

March 2018

Programming Learning Support Methods based

on Adaptive Hypermedia and Program

Visualization

Yu Yan

Submitted for the Degree of Doctor of Philosophy

March 2018

Abstract

Computer programming skill is required by various fields for the development of

information society. To better prepare students for research and work, computer

programming has been implemented for not only the field of computer science but

also other fields in a growing number of universities on a global scale. In some

countries such as the UK and Japan, high school students and even elementary

school students are expected to understand basic knowledge about algorithms and

simple programs. However, some beginners are having difficulty learning computer

programming. One of the problems is that beginners have difficulties understanding

the behavior of a program at runtime and the concepts included in the program. In

addition, there is a lack of learning materials that are well constructed and appro-

priate for each individual beginner. Addressing those issues, research on computer

programming education has proposed many educational support methods that uti-

lize new information and communication technology and lead to learning support

tools. In particular, methods based on Program Visualization (PV) and Adaptive

Hypermedia (AH) technology are popular now.

PV is for static and dynamic graphical representations of computer programs

and processed data. Educational PV tools can graphically show the behaviors of

programs at runtime, step by step, to help instructors and students in computer

programming education activities. AH provides links or content most appropriate to

the current user according to a model of the user’s goals, preferences and knowledge.

v

The basis of AH-based support methods is to construct Personalized E-learning

for Programming (PEP) to recommend individual beginners the most appropriate

learning content or learning plan.

This research focuses on helping beginners to learn computer language syntax

and enhancing programming lectures and PEP. It proposed the following educational

method to solve the issues in existing PV tools and PEP.

A Lecture-Oriented PV Tool (LOPV tool) is for promoting students’ under-

standing of program syntax and concepts during lectures with the following features:

(1) It does not show any information to students that is irrelevant to teaching con-

tents when it visualizes target programs, (2) it is directly launched from teaching

contents with the programs to be visualized, (3) it does not require any change in

the appearance of the target program source code, (4) it shows visualization results

with high enough visibility and more easily distinguishable expressions, (5) it offers

enough visualizations so that beginners can learn all of the beginner-level program

syntax, and (6) it provides enough functions that are convenient for instructors to

operate in the lectures.

Syntactic Knowledge Point based Personalized E-learning for Pro-

gramming (SKP-based PEP) is an approach to implement the PEP model.

Syntactic Knowledge Point (SKP) is a way to describe the syntactic knowledge con-

tained in a program source code. SKP-based PEP monitors individual learners’

learning statuses by estimating their understanding of each type of syntactic knowl-

edge. In addition, it allows instructors to check the rationality of the knowledge

distribution in their learning materials in a more convenient way. Furthermore, it

can recommend appropriate learning contents for programming to each learner.

Since 2015, PROVIT (PROgram VIsualization Tool), an experimental LOPV

tool developed in the author’s university, has been consecutively and actively used by

the instructors to enhance their lectures. The results of the experimental application

in an introductory C programming course show that the LOPV tool is necessary to

support lectures on programming. For SKP-based PEP, numerical experiments were

conducted and the results of the experiments verify the correctness of the proposed

algorithms.

vi

適適適応応応型型型ハハハイイイパパパーーーメメメデデディィィアアアとととプププロロログググラララムムム可可可視視視化化化ににに基基基づづづ

くくくプププロロログググラララミミミンンングググ学学学習習習支支支援援援手手手法法法

Yu Yan

学学学位位位論論論文文文概概概要要要

情報社会の発展につれて、コンピュータプログラミングスキルはいろんな分野

で求められている。学生が将来の研究と仕事でより役立つために、コンピュー

タ科学関連領域のみでなく、多くの他分野関連の大学や高校でもコンピュータ

プログラミングが勉強されている。一部の国（イギリス・日本など）では、高

等学校や小学校の学生までに簡単なコンピュータプログラムやアルゴリズムに

関する基本知識を持つことが期待されている。しかし一部の初学者はプログ

ラミングの学習に困難を感じている。困難の一つはプログラムが実行されて

いるときの振る舞いやプログラムに関する概念が理解しにくいことであり、

もう一つの困難は学習者一人ひとりの学習状況に合わせた学習用教材の提供

ができないことである。それらの困難を解決するために多くのプログラミン

グ教育支援手法やツールが研究者より提案されている。その中でプログラム

可視化（PV: Program Visualization）と適応型ハイパーメディア（AH: Adaptive

Hypermedia）に基づいた方法やツールが注目されている。

PVは実行中のプログラムの内部情報やデータ処理の結果を視覚的に表示す

る技術である。PVの特徴を活用し、学習支援用PVツールはプログラミング初

学者のプログラム概念の理解促進に利用されている。一方AHは利用者の目標・

知識背景と学習の出来具合に合わせ利用者に最もふさわしい学習プランや学習

内容を提案する、効率的な学習支援手法である。AH ベースのプログラミング

学習支援手法は学習者一人ひとりに最適な学習内容を提示することを目標にし

ている。

本研究が目指しているのは、プログラミング初学者のコンピュータ言語文法

の理解を促進することと、教員のプログラミング講義および学習者の状態に個

別対応可能支援環境を強化することである。本研究は以下の二つの支援手法を

提案した。

vii

• Lecture-Oriented Program Visualization Tool (LOPV Tool): これはPV技術

によりプログラミングの講義の中で学生のプログラム文法や概念に対

する理解度の向上を目指すものである。従来の教育用PVツールに比

べLOPVツールは以下の特徴を有する

1. 講義の中で学生に不必要な情報などは一切表示しない。

2. 教員の教材と連携しており、教材画面から直接起動できる。

3. 本ツールと連動する教材やプログラムの外観変更は不要である。即

ち教員への付加的な負担が最小限となる。

4. 可視化の結果を十分な明瞭さで示す。

5. 講義に必要な十分な可視化機能を提供する。

6. 教員に十分な機能と便利さを提供する。

• Syntactic Knowledge Point based Personalized E-Learning for Programming

(SKP-based PEP): 本手法はAH技術を生かし学習者の状態に応じた学習内

容の推薦を可能にしたものである。SKPはプログラムソースコードに含ま

れる知識情報を表現するための方法である。本手法は学習者の、それぞれ

のSKPに対する理解度を推定することにより学習者一人ひとりの学習状態

をモニタする。SKPはまた、教材中の文法知識情報の分布状況を分析し、

教材内容の配分の合理性を簡単にチェックする方法を提供している。さら

に本手法は学習者一人ひとりに最適な学習資料を推薦することが可能であ

る。

2015年以来、本研究で開発されたLOPV toolの実験システム–RPOVIT(PROgram

VIsualization Tool)が本学で積極的に利用されている。本学の講義「プログラミ

ング入門」での応用結果がPROVITの有効性を示している。SKP-based PEPに

おいては, 学習者の状態取得と学習内容推薦のためのアルゴリズムの有効性が

実験により検証された。

Acknowledgements

I would like to express my sincere gratitude to my advisor, Prof. Hirokuni

Kurokawa, for his academic guidance over the past three years for the Ph.D and one

and a half years for the master’s. He has guided me on not only just writing and

research, but also on professional expectations of doctors. His quality for thoughtful

and profound research will inspire me in all of my life.

I would like to thank Prof. Yoshioka Rentaro, Prof. Lei Jing and Prof. Yan

Pei of the University of Aizu for taking the time to review my thesis and making

precious comments to help me polish up my research and improve the quality of my

dissertation.

I would like to thank Prof. Yasuhiro Hisada, Prof. Kohei Otsuyama and Prof.

Hirohide Demura of the University of Aizu for using PROVIT in their lectures and

helping me finish the research on LOPV tool.

I would like to thank Prof. Jeremy Perkins for checking the English grammar

and word choice in my dissertation.

I would like to thank all my friends: International students of the University

of Aizu have broadened my horizons and increased my knowledge of the world;

the current and previous members of the Computer Networks Laboratory of the

University of Aizu and my roommates living in Somei House have helped me with my

life in Japan; Some Japanese students and friends, Moe Kaneda, Shiori Watanabe,

Yumi Matsui and Hayato Watanabe have made contributions on my improvements

in my Japanese ability; Especially, my Chinese friends, Huiwen Yang, Xin Fan and

Fan Zhang, have given me spiritual comfort and encouragement.

Lastly, I would like to thank my family and my uncle’s family for all their strong

love and unconditional support for all my pursuits. My parents have taught me

viii

ix

though their actions how to love and respect others. They have raised me with a

love of science since I was a child. In addition, my sister, Xue Yan, who is also one

of my best friends, has given me so much help with my life. Furthermore, my uncle,

Prof. Yue Zhao, has taken great care of my life in Japan. His motivation and high

sense of responsibility have influenced me greatly and helped me persevere to finish

doctorate.

Contents

Abstract iv

Acknowledgments viii

List of Abbreviation xv

1 Introduction 1

1.1 Program Visualization (PV) . . . . . . . . . . . . . . . . . . . . . . . 3

1.2 Adaptive Hypermedia (AH) . . . . . . . . . . . . . . . . . . . . . . . 4

1.3 Motivations of the Dissertation . . . . . . . . . . . . . . . . . . . . . 5

1.4 Contributions of the Dissertation . . . . . . . . . . . . . . . . . . . . 7

1.5 Structure of the Dissertation . . . . . . . . . . . . . . . . . . . . . . . 7

2 Lecture-Oriented PV Tool 10

2.1 LOPV Tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.2 Experimental Implementation of LOPV tool . . . . . . . . . . . . . . 12

2.2.1 PROVIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2.2 Design of PROVIT as An LOPV Tool . . . . . . . . . . . . . 14

2.2.3 Implementation of PROVIT as An LOPV tool . . . . . . . . . 17

2.3 Experimental Application of LOPV tool . . . . . . . . . . . . . . . . 19

2.3.1 Functions used in each lecture . . . . . . . . . . . . . . . . . . 22

2.3.2 Accumulated use time . . . . . . . . . . . . . . . . . . . . . . 24

2.3.3 Evaluation by Students . . . . . . . . . . . . . . . . . . . . . . 25

2.3.4 Evaluation by Instructors . . . . . . . . . . . . . . . . . . . . 27

x

Contents xi

3 Syntactic Knowledge Point-based Personalized E-learning for Pro-

gramming 28

3.1 Personalized E-learning for Programming . . . . . . . . . . . . . . . . 28

3.2 SKP-based PEP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.3 Syntactic Knowledge Point (SKP) . . . . . . . . . . . . . . . . . . . . 31

3.3.1 Definition of SKP . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.3.2 SKP and AST . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

3.3.3 Textual Expression of SKP . . . . . . . . . . . . . . . . . . . . 33

3.4 Algorithms in SKP-based PEP . . . . . . . . . . . . . . . . . . . . . . 35

3.4.1 SKP Extraction and SKPV . . . . . . . . . . . . . . . . . . . 35

3.4.2 Learning Topic Database . . . . . . . . . . . . . . . . . . . . . 36

3.4.3 Learning History Database . . . . . . . . . . . . . . . . . . . . 37

3.4.4 Learning Status Estimation . . . . . . . . . . . . . . . . . . . 37

3.4.5 Extraction of SKP with Poor Understanding . . . . . . . . . . 39

3.4.6 Learning Topic Recommendation . . . . . . . . . . . . . . . . 40

3.5 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.5.1 SKP Extraction . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.5.2 Learning Status Estimation . . . . . . . . . . . . . . . . . . . 43

3.5.3 Extraction of SKP with Poor Understanding . . . . . . . . . . 46

3.5.4 Learning Topic Recommendation . . . . . . . . . . . . . . . . 49

4 Conclusion 51

Bibliography 53

Appendix A Implementation of SKP Extraction 59

List of Figures

2.1 An example of PROVIT’s Run viewer. (a) shows the code view, (b)

shows the image view, (c) shows the console view, and (d) shows the

control of buttons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2 Experimental implementation of new LOPV techniques with PROVIT.

(a) is the large virtual cursor, (b) is the Array viewer, (c) is the con-

trols of standard input redirection, (d) shows the visualization of the

return value of the executed function, (e) shows the role of variables

indicated by color, (f) shows the blinking red colored underling, and

(g) is the keyboard shortcuts for operations of the Run viewer. . . . . 15

2.3 Examples of PROVIT URLs grouped by lecture with page number

and slide number of related teaching materials. . . . . . . . . . . . . . 20

2.4 PROVIT applied to an existing lecture. (a) shows a power point

slide in the original teaching materials. Clicking the PROVIT URL

embedded into the label in the bottom of the slide will start PROVIT,

and in (b) PROVIT with the example program in the code view is

shown on the projection screen . . . . . . . . . . . . . . . . . . . . . 22

2.5 Student evaluation of the helpfulness of PROVIT to understand ex-

ample programs in each lecture, where A is the most helpful and E

is the least helpful. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.1 Model of Personalized E-learning for Programming . . . . . . . . . . 29

3.2 Model of SKP-based PEP. In (a) learning status is the learners’ un-

derstanding of each type of syntactic knowledge (SKP), and in (b)

the common feedback from a learner is shown. . . . . . . . . . . . . . 30

xii

List of Figures xiii

3.3 The Abstract Syntax Tree of Listing 3.1 . . . . . . . . . . . . . . . . 32

3.4 SKP distribution by lecture . . . . . . . . . . . . . . . . . . . . . . . 44

3.5 Estimated understanding of particular types of SKP for the first 100

days. (a) is for “DCFH02main”, (b) is for “EX F05EX URY”, (c) is

for “ST CMP04ST IF” , and (d) is for “EX BIN82double”. . . . . . . 45

3.6 Groups of s4’s types of SKP with poor understanding, where (a) shows

the types of SKP related to function declaration, (b) shows the types

of SKP related to FOR/IF statements, and (c) shows the types of

SKP related to assignment expression. . . . . . . . . . . . . . . . . . 47

3.7 m and d calculated for each lecture topic, based on s1’s learning status

(λ = 0, R(t) = Ø). (a) shows the results on the 31st day, and (b)

shows the results on the 80th day. . . . . . . . . . . . . . . . . . . . . 49

3.8 m and d calculated for each lecture topic on the 80th day (λ =

1, R(t) 6= Ø). (a) shows the results based on the learning status

of s1, and (b) shows the results based on the learning status of s4. . . 50

List of Tables

2.1 Course distribution by lecture . . . . . . . . . . . . . . . . . . . . . . 21

2.2 Frequency of use of PROVIT’s functions . . . . . . . . . . . . . . . . 22

2.3 Main Functions of PROVIT . . . . . . . . . . . . . . . . . . . . . . . 23

2.4 Accumulated use time (in minutes) by instructors for 2015 and 2016.

In each cell, the total time across all users and the number of users

are shown via the form “time/number”. . . . . . . . . . . . . . . . . . 24

3.1 Examples of the textual expressions of leaf node types . . . . . . . . . 34

3.2 Examples of the textual expressions of inner node types . . . . . . . . 34

3.3 Examples of the textual expression of the local role . . . . . . . . . . 35

3.4 Examples of SKP in function head declaration . . . . . . . . . . . . . 35

3.5 Distribution of students’ understanding level . . . . . . . . . . . . . . 47

3.6 s4’s SKP with poor understanding on the 110th day . . . . . . . . . . 48

xiv

List of Abbreviation

CS1: Introductory computer programming course

PV: Program Visualization

PV tool: Program Visualization tool

AV: Algorithm Visualization

AH: Adaptive Hypermedia

ICT: Information Communication Technology

IDE: Integrate Development Environment

TM: The Teaching Machine

VPS: Visual Program Simulation

LOPV: Lecture-Oriented Program Visualization

LOPV tool: Lecture-Oriented Program Visualization tool

LOPV technique: Lecture-Oriented Program Visualization technique

PROVIT: PROgram VIsualization Tool

PEP: Personalized E-learning for Programming

SKP: Syntactic Knowledge Point

SKP-based PEP: Syntactic Knowledge Point-based Personalized E-learning for Pro-

gramming

GUI: Graphical User Interface

CVM-EP: C Virtual Machine for Educational Purpose

PROVIT URL: PROgram VIusalization Tool Uniform Resource Locator

PDF: Portable Document Format

HTTP: Hypertext Transfer Protocol

JNLP: Java Network Launching Protocol

HTML: Hypertext Markup Language

xv

List of Tables xvi

AST: Abstract Syntax Tree

AI: Artificial Intelligence

VR: Virtual Reality

Chapter 1

Introduction

Computer programming skills are required by various fields for the development

of information society. For example, besides computer careers, industries also re-

quire that employees have basic programming skills. To better prepare students for

research and work, computer programming has been implemented for not only the

field of computer science but also other fields in a growing number of universities on

a global scale [1]. In some countries such as the UK and Japan, high school students

and even elementary school students are expected to understand basic knowledge

about algorithms and simple programs [2].

However, some beginners are struggling to learn computer programming. For

example, based on [3], the world wild pass rate of CS1 (introductory computer pro-

gramming course) among almost all universities is 67.7%. Although the pass rate

is not alarmingly low, there is considerable potential for improvement. Another ex-

ample is PC-koshien, a computer programming contest for all-Japanese high school

students, in which participating teams submit their answer source codes for each

programming problem to get scores. According to the results of PC-koshien’s pre-

judging contests from 2011 to 2016, about 10.7% of the teams got 0 points each

year, though the answer program source codes for PC-Koshien’s simplest problem

only include “standard input”, “standard output” and basic arithmetic operations.

Analysis of beginners’ problems has been published. One of those problems is

that beginners have difficulties understanding the behavior of a program at runtime

and concepts included in the program. According to [4] and [5], some beginners only

1

Chapter 1. Introduction 2

focus on the results following program execution rather than the behaviors of the

program at runtime. As a result, they are unaware of what happened in the program

at runtime, and so for them, learning to program is considered as grasping the rules

to write code in a particular language instead of designing behaviors to be executed

by computers. In addition, according to [6], some concepts (such as pointer in C

language) are difficult for many beginners who have vague and incomplete knowledge

of computers. They do not understand how to work among those concepts.

Another of the problems leading to beginners’ difficulties in learning to program

is there is a lack of appropriate learning materials for each individual learner. In some

institutions of computing such as the author’s university, a computer programming

course consists of approximal 80 students with one single instructor. However, some

students suffer from disparities between their own level of programming skills and

the level of the course, as it progresses. And the results from [7] also show it is

difficult for instructors to design programming courses which can meet the needs

of the heterogeneous students (including effective students who can write programs

and learn programming with moderate effort and ineffective students who can not

write correct programs and need more personal attention and cognitive support to

learn programming).

Over the past decades, proposals with methods to solve the above problems

have been published. Those solutions utilize technologies such as Gamification [8],

Software Visualization [9] (including Program Visualization (PV) and Algorithm Vi-

sualization (AV)), Automated Assessment [10] and Adaptive Hypermedia (AH) [11].

Those methods lead to learning support tools for instructors and students to teach

and learn programming. For example, there are visualization tools for graphi-

cally showing concepts, algorithms and data structures; automated assessment tools

for automatically grading students’ source code [12]; and tools based on physi-

cal metaphors for reflecting program execution in the visual state of concrete ob-

jects [13] [14]. Among the above methods, with the rapid development of ICT (short

for Information Communication Technology), methods based on PV and AH have

become more important for the support of computer programming education.

1.1. Program Visualization (PV) 3

1.1 Program Visualization (PV)

PV is an important technology for static and dynamic graphical representations

of programs and processed data. Within PV, some visualizations represent program

code while others illustrate the runtime dynamics of programs [6] [15].

PV has been widely applied to author visual debuggers which are used in IDE

(short for Integrate Development Environment) such as Eclipse [16], Netbeans [17]

or GCC/GDB to help programmers debug their programs and improve their effec-

tiveness of software system development.

Studies have shown that PV is also useful for beginners to understand programs

[18]. PV tools can show the behaviors of programs at runtime step by step, and

can show the values in every variable. However, IDE is designed for industry use.

In classes for programming, many IDE functions are too professional and are not

useful for beginners to understand programming language and concepts. Those

complicated functions only make IDEs too difficult for beginners to use [19]. Thus,

in order to improve computer program education, educational PV tools suitable

for beginners have been proposed. Educational PV tools overcome the problems

in IDEs and focus on helping instructors and students in computer programming

education activities. The following are typical educational PV tools that have been

widely used in the past, and are still used currently.

TM (short for The Teaching Machine) [20] is the earliest tool for visualizing a

limited set of C and C++ programs. It shows different stages of visualization results

and dynamic diagrams reflecting the relationships between data.

VIP presents a visual, web-based interpreter for learning C++ programs. It

can visualize a larger set of programs than TM. It has proved to be a profitable

visualization tool for students [21].

Jeliot3 [22], [23] is one of the most-used educational PV tools for Java programs

from the Jeliot family, which has been developed over the past decade. Its key

feature is the fully- or semi-automatic visualization of data and control flows. It

can be run on Windows, Mac, and Linux OS as an independent application or a

plugin for the pedagogical IDE BlueJ. Jeliot3 has been used to improve beginners’

1.2. Adaptive Hypermedia (AH) 4

understanding with positive effects: it has been used in a distance education course

[24] and collaborative learning [25]. And [18] emphasized the affective effects of

Jeliot3 to learners.

ViLLE can simultaneously visualize two kinds of program, Java and C++, with

execution for both forwards steps and backwards steps. [26] reported that ViLLE

has a positive effect for students to learn programming in a lab session.

As Python becomes more popular, UUhistle, as the first educational PV tool for

visualizing the Python program has been proposed. It runs either as an applet on

the web or as a stand-alone application. UUhistle can be used for helping beginners

view behavior of a program at runtime and for giving students VPS (Visual Program

Simulation) exercises where students take the role of computer as executor of a

program [27]. Between 2010 and 2012, UUhistle was used to investigate students’

misconceptions of programs and to explore mistakes students made in VPS exercises

[28].

Jype [29] is another web-based learning tool which visualizes the execution of

Python programs step by step, automatically assesses exercises and gives feedback,

and debugs erroneous solutions. It has many beginner-friendly features such as, the

Matrix framework for visualizing data structures like arrays and trees. It was used

in a summer self-study introductory Python course in 2009, when 19 students took

this programming course using Jype and gave a positive evaluation.

On-line Python Tutor [30] is a web-based PV tool that can be embedded into

digital textbooks and example programs. It works on all modern web browsers for

beginners in exercise sessions or self-study. Over 200,000 people have used it from

2011 to 2013 and have given it positive evaluations.

1.2 Adaptive Hypermedia (AH)

AH provides links or content most appropriate to the current user according to a

model of the user’s goals, preferences and knowledge [11]. AH has been widely used

in personalized e-learning [31] since the aim of personalized e-learning is to find an

effective way that provides dynamic and optimal learning processes or appropriate

1.3. Motivations of the Dissertation 5

learning contents for individual learners, according to those learners’ needs in or-

der to enhance their learning ability [32]. Some research on computer programming

education has utilized AH and their method to construct personalized e-learning en-

vironments for programming recommends individual beginners the most appropriate

content or plan.

JavaGuide [33] guides students to choose appropriate Java programming ques-

tions to exercise by offering them their completion of each question and the corre-

lation between the question and Java programming knowledge.

Protus [34] is also for learning Java programming. It recommends individual

students appropriate learning sequences according to their own learning styles;

[35]’ method is for learning C program. It can recommend individual learners

their most interested in exercise problems by referring to other learners’ performance

of those problems and being based on the collaborative filtering algorithm;

For supporting to learn database programming language, [36] proposes an ap-

proach to provide individual learners personalized learning guidance based on their

performance of the language.

ELaC [37, 38] is a method to recommend personalized learning materials based

on learners’ background and their performance of each sections in the materials.

Although the other research shows that their methods or approaches are effective, an

experimental result of ELaC indicated it is necessary to get learners’ understanding

of each type of syntactic knowledge for the highly accurate recommendation.

1.3 Motivations of the Dissertation

Programming is the process in which programmers interact with computer sys-

tems by writing, testing and debugging computer programs. For this, a programmer

is required to have the following two basic skills: having the knowledge of computer

language syntax and semantics and being able to design programs to solve prob-

lems. Thus, learning to program consists of learning computer language syntax that

requires memorization and comprehension abilities (for the first skill) and learning

algorithms that require abstraction and logical thinking abilities (for the second

1.3. Motivations of the Dissertation 6

skill) [39]. On the other hand, learning computer language syntax is the basis

of learning algorithm. For example, many beginners’ failures in programming are

caused by computer language syntax with poor understanding. Thus, it is important

to help beginners learn computer language syntax.

For beginners, the following show their main sources of learning to program:

1. being taught at lectures;

2. exercising in lab;

3. learning by themselves.

Although there are a lot of learning support methods to optimize (2) and (3) [19],

there is little research on computer programming education that focuses on (1).

Thus, it is necessary to provide a method to enhance lectures.

In existing Personalized E-learning for Programming (PEP for short), the ap-

proach to implement personalized recommendations can be described as follows:

1. collect individual learner feedback;

2. analyze the feedback;

3. recommend an individual learner some appropriate learning contents or a

learning plan according to the results of the analysis.

For (1), usually, the learner feedback which can be collected is what learners have

read, such as learning materials taught and what learners have submitted, such as

answer source codes. Furthermore, for a highly accurate recommendation, in (2) it is

necessary to get learners’ understanding of each type of syntactic knowledge from the

analysis. However, there is no research which offers an approach to quantify learners’

understanding of each type of syntactic knowledge from the learner feedback, and

to do this, programming educators need to help to complete a quantitative analysis.

Thus, it is necessary to offer such a method to analyze the learner feedback by

computer systems.

1.4. Contributions of the Dissertation 7

1.4 Contributions of the Dissertation

Based on the above motivations, this dissertation proposes a new educational PV

tool – Lecture-Oriented PV tool (LOPV tool for short) to promote students’ under-

standing of computer language syntax given in lectures. This dissertation proposes

some new techniques to overcome the problems in existing educational PV tools,

improving them to be lecture-oriented. We also conducted a two-year application

experiment to confirm the proposal. According to the results of the experiment, the

research on LOPV tools is necessary to support lectures on programming and the

proposed techniques are effective.

In addition to above contribution, a new method to solve the issues in PEP is

offered: SKP-based PEP (short for Syntactic Knowledge Point-based Personalized

E-learning for Programming). Experiments have proved that SKP-based PEP is

effective in the following ways:

• It leads to computer systems that offer learners their individual learning sta-

tuses (their understanding of each type of syntactic knowledge);

• It allows one to check the rationality of the knowledge distribution in learning

materials in a more convenient way;

• It leads to computer systems that recommend appropriate learning contents

for programming to each learner.

1.5 Structure of the Dissertation

The rest of the dissertation is organized as follows:

• Chapter 2 describes Lecture-Oriented PV tool and new LOPV techniques. An

educational PV tool – PROVIT (short for PROgram VIsulization Tool) which

is developed by our laboratory has been updated to be a LOPV tool with

the techniques. In addition, the results of the experimental application that

PROVIT has been used on a regular course on C programming for two years

(2015 and 2016) are also reported;

1.5. Structure of the Dissertation 8

• Chapter 3 describes algorithms in SKP-based PEP, and the evaluations of

numerical experiments for confirming the correctness of those algorithms are

shown;

• Chapter 4 concludes this dissertation and offers discussions about the points

for future work.

Publications

The following papers have been published in peer reviewed journals and confer-

ences. The results presented in Chapter 2 and Chapter 3 are published in these

works.

Refereed Journals

1. Yu Yan, Kohei Hara, Takenobu Kazuma, Yasuhiro Hisada, Aiguo He, “PROVIT-

CI: A Classroom-Oriented Educational Program Visualization Tool”, IEICE

Transactions on Information and Systems, Vol. E101-D, No.2, pp. 447-454,

2017. (Major)

2. Yu Yan, Kohei Hara, Takenobu Kazuma, Aiguo He, “Learning status de-

scription for personalised C language e-learning environment”, International

Journal of Communication Networks and Distributed Systems, Vol. 19, No.3,

pp. 338-356, 2017. (Major)

Refereed International conferences

1. Yu Yan, Kohei Hara, Takenobu Kazuma, Aiguo He, “A Method for Per-

sonalized C Programming Learning Contents Recommendation to Enhance

Traditional Instruction”, Proc. of 31st. IEEE International Conference on

Advanced Information Networking and Applications, pp. 320-327, Taipei Tai-

wan, March 2017. (Major)

2. Yu Yan, Hiroto Nakano, Kohei Hara, Takenobu Kazuma, Aiguo He, “A Web

1.5. Structure of the Dissertation 9

Service for C Programming Learning and Teaching”, Proc. of 10th Interna-

tional Conference on Complex Intelligent and Software Intensive Systems, pp.

414-419, Fukuoka Institute of Technology Japan, July 2016. (Major)

3. Yu Yan, Kohei Hara, Takenobu Kazuma, Aiguo He, “A Method to Describe

Student Learning Status for Personalized Computer Programming e-learning

Environment”, Proc. of 30th. IEEE International Conference on Advanced In-

formation Networking and Applications, pp. 231-238, Crans-Montana Switzer-

land, March 2016. (Major)

4. Yu Yan, Hiroto Nakano, Kohei Hara, Shota Suga, Aiguo He, “C Programming

Learning Support System and Its Subjective Assessment”, Proc. of 14th.

IEEE International Conference on Computer and Information Technology, pp.

231-238, Xi‘an China, September 2014. (Major)

Chapter 2

Lecture-Oriented PV Tool

In this chapter, we will introduce the LOPV tool (short for Lecture-Oriented PV

tool) and an approach to implement an LOPV tool by utilizing some new LOPV

techniques. Then, we will describe an experimental LOPV tool – PROVIT (PRO-

gram VIsualization Tool). Finally, the evaluation results of the experimental appli-

cation with PROVIT will be reported.

2.1 LOPV Tool

An LOPV tool is an educational PV tool that is designed for promoting students’

understanding of program syntax and concepts during lectures. An effective lecture

to teach programming should be based on the seamless combination of teaching

contents and instructor’s actions including his words, facial emotions and gestures.

There is some equipment that can effectively enhance the combination such as, a

blackboard, an instructor’s computer or a wall-size projection screen.

In order to be seamlessly combined with teaching contents and instructors’ ac-

tions, an LOPV tool should be designed as follows:

• It shouldn’t show any information to students that is irrelevant to teaching

contents when it visualizes target programs. For example, when existing edu-

cational PV tools visualize programs, their functions which are only suitable

for self-study will be shown to users. An example of one such function, “help”,

is designed to assist users when they do not know how to operate the GUI

10

2.1. LOPV Tool 11

(short for Graphical User Interface) of the PV tool. Those functions are not

useful to enhance students’ understanding on lectures and will detract from

the students’ attention on their studies;

• It should be directly launched from teaching contents with the programs to be

visualized. For example, in existing educational PV tools, it takes additional

time for the instructors to load, type or paste example program source code

into those tools during the lectures;

• It shouldn’t require any change in the appearance of the target program source

code. For example, in exiting educational PV tools such as ViLLE, in order

to control and customize the visualization of the target program, they require

additional information such as “role information of variables [40]” for the pro-

gram. Therefore, if those tools are applied to the lectures, instructors need

to spend additional working time to define that information for the program

and it is also not easy to show a variation of the program by instantaneously

editing it;

• It should show visualization results with high enough visibility and more easily

distinguishable expressions. For example, the visibility should be the same or

higher than a powerpoint slide showing teaching contents. And for students

to follow instructors’ intents more easily, there should be different expressions

for visualizing the same program syntax with different roles;

• It should offer enough visualizations so that beginners can learn all of the

beginner-level program syntax. For example, among existing educational PV

tools, there is no visualization for a large-size 2 dimensional array;

• It should provide enough functions that are convenient for instructors to op-

erate in the lectures.

2.2. Experimental Implementation of LOPV tool 12

2.2 Experimental Implementation of LOPV tool

In this section, based on the above definition of the LOPV tool, we propose an

approach that will update an educational PV tool (PROVIT short for PROgram

VIsualization Tool) to become an LOPV tool with LOPV techniques.

2.2.1 PROVIT

PROVIT is aimed at improving beginners’ understanding of C program syntax

by visualizing the processing of C program execution. It is developed by Java and

Java FX technology to support multiple operating systems. It includes a CVM-EP

(short for C Virtual Machine for Educational Purpose) [41], a program code editor

and a Run viewer for user to write, run and check their C programs.

Figure 2.1: An example of PROVIT’s Run viewer. (a) shows the code view, (b)shows the image view, (c) shows the console view, and (d) shows the control ofbuttons.

Figure 2.1 shows the Run viewer of PROVIT. It has a code view, an image

view and a console view. It offers following basic functions for the user to check C

programs:

• One step execution by clicking the “Forward” button;

• Returning to the previous step by clicking the “Backward” button;


• Continuative execution to a breakpoint or the end of the program by clicking

the “Go” button;

• Execution from the beginning of the program by clicking the “Restart” button.

Following the above functions, code view displays the source code of the program

as follows:

• Indicate all steps that have been executed with light blue underlining for the

user to trace the runtime execution of the program;

• Indicate the step that will be executed in the next one step execution with a

red underlining;

• Set or clear a breakpoint by clicking on any element of the source code. (Break-

points are indicated by light green rectangles.)

The image view visualizes the current status of the running C program by graphically

showing the following information:

• variable data type, variable name and its current value;

• function name.

The console view simulates the console of the computer, showing the standard input

and output of the program.

Although PROVIT has many useful visualization functionalities, we found they

were not enough to solve the following problems when PROVIT was used in a regular

programming course for the first year students in the author’s university:

• In this course, basic concepts about array data structure such as dimension,

size and zero-based indexing are taught and then, students learn applications

of large 2-dimensional arrays. However, many students had difficulty under-

standing them.

• In many example programs used in this course, return values are directly

referenced in expressions such as the one below:


if(scanf("%d", &a) != 1){

(do something)

}

However, in order to show a return value by using PROVIT, the source code

needs additional variables and assignment statements such as those below:

int v = scanf("%d", &a);

if(v != 1){

(do something)

}

Therefore, the instructors have to change those example programs when they

want to use PROVIT.

In addition, if instructors want to visualize their example programs by PROVIT,

they need to load, type or paste the programs in lectures. That will waste class

time. Furthermore, the Run viewer of PROVIT is only suitable for personal use and

its visibility if not enough for lecture use.

2.2.2 Design of PROVIT as An LOPV Tool

In order to solve the problems in PROVIT mentioned in Section 2.2.1 and im-

prove PROVIT to be an LOPV tool, new LOPV techniques have been designed as

shown in Figure 2.2.

For students to easily trace what an instructor is teaching and follow instructors’

intents, PROVIT has been improved as follows:

• A large virtual cursor was added to replace the usual mouse cursor in the Run

viewer.

• The red underlining was changed to be a blinking line in the code view.


Figure 2.2: Experimental implementation of new LOPV techniques with PROVIT.(a) is the large virtual cursor, (b) is the Array viewer, (c) is the controls of standardinput redirection, (d) shows the visualization of the return value of the executedfunction, (e) shows the role of variables indicated by color, (f) shows the blinkingred colored underling, and (g) is the keyboard shortcuts for operations of the Runviewer.

• In the image view, the role of a variable was marked by a colored background:

if a variable would be referred to at the next execution step, its background was

blue; if a variable would be changed at the next execution step, its background

was red.

In order for the visualization results to have higher visibility, the following im-

provements were made for PROVIT:

• All three views of the Run viewer support the zoom in and zoom out operations

for showing the details of visualization elements.

• The Run viewer overlays the whole desktop of an instructor’s computer when

PROVIT is used to visualize the target program.

For instructors to seamlessly combine PROVIT into their lectures with minimum

additional time, PROVIT has been improved as follows:


• The following ways were designed for an instructor to feed data for the stan-

dard input: Keyboard (as usual); redirection from the preset text data; redi-

rection from an additional text file. Standard input redirection is very useful

when the size of the input data is large. For example, in Figure 2.2, the tar-

get program needed to load a gray-scale picture from the standard input and

“redirection from preset text data” was used to save class time.

• If an instructor creates his teaching materials using Microsoft PowerPoint [42],

a quick-start method can be used for him to launch PROVIT with a target

program and standard input data from a PowerPoint slide being displayed.

The method offers a PROVIT web service for instructors to upload example

source codes and input data which they want to use in lectures to a HTTP

(short for Hypertext Transfer Protocol) server. Through this service, it offers

a PROVIT URL (short for PROVIT Uniform Resource Locator) for each ex-

ample program code uploaded. Accessing the URL from a web browser will

directly launch PROVIT, showing its Run viewer with the target program in

its code view and the input data in its console view. A PROVIT URL can be

embedded in a PowerPoint slide or a PDF (short for Portable Document For-

mat) file so that instructors can launch PROVIT from the teaching materials

being displayed on a projection screen.

In order to offer more visualization functions for instructors to use in lectures,

the following visualization techniques have been designed on a trial basis:

• Array viewer for visualization of array variables: It can show the value of

each element or all elements of an array as a monochrome image since in

introductory programming courses, arrays are usually used to process simple

image data. As shown in Figure 2.2(b), the example program taught to the

first year students in the author’s university has loaded a monochrome image

into the array variable “img” and saved its inversion to the array variable

“out”. The left Array viewer shows values in some elements of the array

“img” while the right Array viewer shows all of the data in the array “out” as

a monochrome image.


• Return value of functions: If the return value of a function will be referenced

in future steps, the information of the function is shown in the image view

after being executed completely. For example, as shown in Figure 2.2(d),

“scanf()” was repeatedly called at line 45 of the program and its return value

was referenced. The last four results of the function call, including the type

of return value, were displayed. Therefore, it became unnecessary to add

additional variables and assignment statements to show the return values of

functions.

In addition, for instructors to conveniently operate PROVIT in lectures, all op-

erations of the Run viewer have been improved to be operated not only by pointing

devices but also by keyboard shortcuts.

2.2.3 Implementation of PROVIT as An LOPV tool

The GUI and some functions of PROVIT are developed by Java FX technology.

In order to provide PROVIT web service, the Apache HTTP Server [43] is used.

The contents of each course are allotted a directory under the root of the server’s

content directories. The files in each course directory are as follows:

• provit.jar: The body of PROVIT.

• provit.jnlp: A text file in the JNLP (short for Java Network Launching Proto-

col) format. It is created by Netbeans and is for launching PROVIT as a Java

Web Start application [44].

• web files: A directory created by Netbeans.

• files of example program source codes: All C program source codes to be used

in lectures via PROVIT. They are uploaded by the instructor.

• files of input data: Text format data files for the standard input of example

programs. They are uploaded by the instructor.

• HTML script files: Created by PROVIT web service. Each file corresponds to

an example program source code with file name “program name. html”.


Therefore, the format of the PROVIT URL is “http://host-name/course-

name/program-name.html”. An example of the HTML (short for Hyper-

text Markup Language) script file is shown as Listing 2.1.

Listing 2.1 Example of HTML script file

1 <html><head>

2 <script src=” ./ web− f i l e s / d t j a va . j s ”>

3 </ script><script>

4 func t i on launchPROVIT( j n l p f i l e ) {

5 dt java . launch ({

6 u r l : ’ . / p rov i t . jn lp ’ ,

7 params : {

8 startMode : ”run” ,

9 windowMode : ”modal” ,

10 sourceCode : ”programFileName” ,

11 inputData : ” inputDataFileName”

12 } ,

13 j n l p c on t en t : ’ ’

14 } ,

15 {

16 java fx : ’8 .0+ ’

17 }

18 ) ;

19 re turn f a l s e ;

20 }

21 dt java . addOnloadCallback ( launchPROVIT) ;

22 </ script>

23 </head></html>

The meanings of key elements in the HTML file are as follows:

– The parameter “startMode” (line 8) with value “run” controls PROVIT

to directly load the example program and the input data and show them

using its run viewer;

– The parameter “windowMode” (line 9) with value “modal” controls PROVIT

to show its window at the front of the client computer screen so that it

2.3. Experimental Application of LOPV tool 19

is ready to be used by the instructor;

– “programFileName” (line 10) indicates the source code file path name of

the example program;

– “inputDataFileName” (line 11) indicates the path name of the text data

file for the program to read as standard input.

• course-name.html: Course homepage script file created by PROVIT web ser-

vice. It is for showing a list of PROVIT URLs of this course on a web browser

for directly launching PROVIT with an example program. Figure 2.3 shows

an example of such a file loaded in a web browser [45]. This list includes

the PROVIT URLs for all example programs used in a first-year program-

ming course in the author’s university. This list also includes the following

information for each program:

– Lecture No.;

– Lecture description;

– Title of example program embedded with a hyperlink to its PROVIT

URL;

– Teaching material information corresponding to the program.

That information can optionally be uploaded along with the example program

codes.

2.3 Experimental Application of LOPV tool

When using an LOPV tool in a lecture, its effectiveness is verified by considering

four aspects: Functions used in each lecture (shown by Section 2.3.1), accumulated

use time in each lecture (shown by Section 2.3.2), evaluation by students (shown by

Section 2.3.3), and evaluation by instructors (shown by Section 2.3.4). In order to

do this, the improved PROVIT has been used in the classroom of a regular course

“Introduction of Programming” in the author’s university since 2015. This course

is given to about 240 first-year students by 3 instructors from April to July for 16


Figure 2.3: Examples of PROVIT URLs grouped by lecture with page number andslide number of related teaching materials.

weeks every year. Each week has one 90-minute lecture teaching C language and

computer programming. Table 2.1 shows the main topics and basic concepts taught

in each lecture of this course. The teaching materials used by the instructors are

made by Microsoft PowerPoint.

Before the experiment, the following preparation was done:

• All example program source codes that would be used by the instructors in

their lectures and all input data for the standard input of example programs

were uploaded on the PROVIT web server.

• For each slide including an example program, a hyperlink of PROVIT URL

corresponding to the program was embedded for instructors to easily trace it

using PROVIT.

• Since the user interface of PROVIT is very simple, there is no instructions

document being offered to the instructors. Only a short explanatory meeting

about PROVIT’s operation was held for them.

The instructors were not forced to use PROVIT. Therefore, during the lectures,

the instructors could show their PowerPoint slides and explain the example program

source code on the slide as usual. When the instructor wanted to run the program

instantly and trace its execution step by step, he only needed to click the hyper link


Table 2.1: Course distribution by lecture

Lec.# Topics and Concepts

1 Introduction, “Hello world”2 Variable, I/O, Assignment, Arithmetic operations(a)3 Variable, I/O, Assignment, Arithmetic operations(b)4 If statement & Switch-case statement5 While statement6 For statement7 1-Dimensional Array8 Special Lecture by invited instructor9 Midterm Exam10 Program structure & Flowchart11 2-Dimensional Array12 Input redirection & Pipe; Image-Processing13 Function(a)14 Function(b)15 Coding style16 Final Exam

embedded on the slide to launch PROVIT which shows a full-screen window that

overlays on the slide. After the explanation was finished, the instructor could close

PROVIT and show the original slide again.

Figure 2.4(a) is an example of teaching material showing source code, compile

commands and execution result of an example program. Figure 2.4(b) shows an

instructor launching PROVIT to explain the runtime behavior of the same example

program in Figure 2.4(a). Unlike existing IDEs and educational PV tools, PROVIT

can display the source code and visualization results to the students with high

enough visibility .

During the experiment in 2015 and 2016, PROVIT was not used in several lec-

tures because of the following reasons:

• Lecture 8,9,10,15 and 16 were not for teaching new contents that need to be

explained by example programs;

• Some instructors could not access the PROVIT web server due to network

problems with the computer they used in the lectures;

• There was an error with preparatory work of embedding the PROVIT URL


(a) (b)

Figure 2.4: PROVIT applied to an existing lecture. (a) shows a power point slidein the original teaching materials. Clicking the PROVIT URL embedded into thelabel in the bottom of the slide will start PROVIT, and in (b) PROVIT with theexample program in the code view is shown on the projection screen

into the PowerPoint slides.

The instructors’ operations of PROVIT were recorded as log data during the

experimental application. In addition, an evaluation from the students about the

helpfulness of PROVIT via a questionnaire was encouraged in 2016. Furthermore,

feedback from the instructors was also elicited.

2.3.1 Functions used in each lecture

Table 2.2: Frequency of use of PROVIT’s functions

Lec.#Functions

1 2 3 4 5 6 7 8 9

12 84 2 1 1 73 81 1 64 55 168 2 2 46 467 2 24 4 5 37 562 4 3 2 19 6 8 111 831 2 4 1 25 8 212 307 78 1 8 21 813 155 1 614 166 1 3

Extraction from the log data yields the frequency that the instructors used


PROVIT’s functions for teaching each lecture in 2015 and 2016, as shown in Table

2.2. The topics taught in each lecture are shown in Table 2.1 and the functions are

listed in Table 2.3. The value in each cell of Table 2.2 is the total number of times

that the corresponding function has been used in the corresponding lecture in 2015

and 2016. From Table 2.2, the following conclusions can be made:

Table 2.3: Main Functions of PROVIT

No. Function

1 To next step(one step execution)2 Back to previous step3 Go(Continuative execution to breakpoint or

the end of program)4 Restart(Execution from the beginning of the program)5 Set/Clear break point6 Array Viewer7 Standard input redirection8 Source code edit9 Source code file load

• The most frequently used function was “To next step” for tracing program

execution. “Go”, “Restart” and “Set/Clear break point” were also frequently

used. In particular, “Go” was more frequently used in lecture 6 and lecture

12 for teaching loop statements and applications of large size arrays. Those

functions can shorten the time to explain example programs;

• “Array viewer” and “Standard input redirection” were actively used in par-

ticular lectures for showing the details and the overview of array variables

and automatically reading data from the standard input to an array variable.

Especially in Lecture 12, where all example programs use large size array vari-

ables, it is difficult for the instructors to run those programs and show the

results effectively during the lecture without an LOPV tool;

• “Source code edit” was often used in the lectures. This function is important

for the instructors to easily and instantly show a variation of an example

program or to make a correction in the program;


• “Back to previous step” was expected to be used to repeatedly and easily

show the change in a variable’s value caused by the execution of the program.

However, it was used in only two lectures, meaning this function is unnecessary

in lectures.

2.3.2 Accumulated use time

Extraction of the log data also yielded the time that the instructors used PROVIT

for each lecture in 2015 and 2016, as shown in Table 2.4. Here, time “During Lec-

ture” is the total time the instructors used PROVIT during a lecture; time “Be-

fore Lecture” is the total time the instructors used PROVIT for checking example

programs and getting familiar with PROVIT on the day before the corresponding

lecture was performed. The use time was counted only when PROVIT’s window

was at the front of the instructor’s computer display. In each cell of the table, the

total time in minutes that PROVIT was used and the number of instructors who

used PROVIT for the corresponding lecture are shown.

Table 2.4: Accumulated use time (in minutes) by instructors for 2015 and 2016. Ineach cell, the total time across all users and the number of users are shown via theform “time/number”.

Lec.#2015 2016

During Lecture Before Lecture During Lecture Before Lecture

1 5.7/22 8.2/1 7.8/1 2.3/1 2.8/23 6.7/1 4.0/1 1.7/14 12.9/1 1.9/1 4.9/15 16.3/2 33.1/1 2.7/16 13.3/2 16.5/2 27.9/3 5.9/17 15.4/2 15.1/2 19.0/2 4.2/111 14.0/1 9.6/2 19.9/2 1.5/112 15.1/2 14.7/2 8.3/2 1.0/113 1.8/1 9.0/1 12.3/2 1.0/114 9.1/2 14.5/2

From Table 2.4, the following can be understood:


• PROVIT was actively used in all of the lectures in which the instructors were

able to use it. The first several lectures were mainly for introducing basic

concepts and only one short example program was explained by using PROVIT

in each lecture. For showing the execution of such a short program by an LOPV

tool, 1 or 2 minutes was enough. In the other lectures, complicated programs

were introduced and repeatedly executed, thus the tool was used for a longer

time in each lecture;

• The time “Before Lecture” can be thought of as the only additional burden

for the instructors to use an LOPV tool. This time was not so great with an

average of only 8.8 minutes. Moreover, in 2016, the time spent before each

lecture significantly decreased;

• PROVIT could not be used in many lectures. The main reason was that the

instructors could not connect their laptop computers to the internet in the

classroom. Therefore, as an LOPV tool, it is not enough to only offer on-line

service. In addition, service for off-line use is also necessary.

2.3.3 Evaluation by Students

To confirm the helpfulness of an LOPV tool, a questionnaire was given to all

of the students in the last lecture of the second year (2016). The questionnaire

consisted of only the following question:

“Did/Would PROVIT help you understand the example programs

shown in each lecture ? ”

Figure 2.5 presents the statistical results of the responses. The numbers on the

horizontal axis correspond to the lecture number in Table 2.1. The answers for

lectures 2 and 3 are summarized together since these two lectures have the same

topics and concepts. The same is true of lectures 13 and 14. “A” means that the

student thought PROVIT was or would be very helpful and “E” means that the

student thought PROVIT was not or would not be helpful at all. From Figure 2.5,

the following can be understood:


Figure 2.5: Student evaluation of the helpfulness of PROVIT to understand exampleprograms in each lecture, where A is the most helpful and E is the least helpful.

• PROVIT, as an LOPV tool, was highly accepted by the students. For most of

the lectures, more than 75% of students answered that PROVIT is helpful in

improving the understanding of the lectures;

• The Array viewer and the visualization for return values were very useful for

teaching arrays (in lectures 7 and 11) and functions (in lectures 13 and 14).

The Array viewer can automatically deal with the number of dimensions and

the size of the array. In addition, it can easily show the relations between

the whole array and any particular element of the array via simple operations.

Visualization for return values helps the instructors to easily explain how to

simply make use of the return values without using additional variables and as-

signment statements. Thus, these new functionalities contribute to promoting

students’ understanding in lectures;

• In lectures 1 and 5, PROVIT was not used. However, more than 65% of

students thought it could be helpful in these lectures if it was used Therefore,

it is necessary to consider using LOPV tools in more lectures;

• In lecture 12, PROVIT received a lower evaluation than in other lectures

with less than 65% of students thinking it was helpful. In this lecture, all

example programs were applications of array variables and implementations

of monochrome image processing, and the Array viewer played an important


role for the explanation of those programs. The reason for the lower evalua-

tion is that the content of this lecture, based on the curriculum, was originally

designed without considering the potential use of an LOPV tool. The instruc-

tors, for the first time, need to spend a lot of time to teach how to feed image

data to a program using standard input redirection and to feed the output of

a program to an image viewer tool using output redirection; An LOPV tool is

not the suitable for teaching those techniques.

2.3.4 Evaluation by Instructors

The instructors of this course confirmed that PROVIT is an effective LOPV tool

to promote students’ understanding of the example programs shown in the lectures.

According to the feedback from the instructors, the following features of the tool

were highly evaluated:

• Ability to quickly launch via PROVIT URL;

• Large virtual cursor;

• Operation via keyboard shortcuts;

• Easy standard input redirection;

• The Array viewer.

The instructors also confirmed it was very helpful that PROVIT required no

additional information for the visualization of the example programs.

Furthermore, the instructors declared that they would continue to use PROVIT

in this course in the future and that they hoped PROVIT could be used in more

advanced courses teaching other concepts such as pointers and structures.

Chapter 3

Syntactic Knowledge Point-based

Personalized E-learning for

Programming

In this chapter, we will describe the model of the personalized e-learning for

programming (PEP short for). Then, the SKP-based PEP will be introduced to solve

the issues in existing PEP and implement the model. We will also introduced some

algorithms in the SKP-based PEP. Finally, the evaluation results of the numerical

experiments for confirming the correctness of those algorithms. will be shown.

3.1 Personalized E-learning for Programming

Figure 3.1 shows the model of Personalized E-learning for Programming (PEP

for short). Learning materials are the resources which will be offered to the

learner. They might be the documents created by educators for lectures or exercises,

or they might be the contents on a web page. Learner feedback is the data

collected from the learner, such as his answer source codes for exercise problems or

examinations, or his background including personal interests, age and experience

in programming. Learning status estimation analyzes the learner feedback and

then offers information about learner status such as the learner’s performance on an

exercise. Recommendation recommends the most appropriate learning contents

28

3.2. SKP-based PEP 29

Figure 3.1: Model of Personalized E-learning for Programming

which come from the learning materials to individual learners based on their learning

status.

There is very little past research that has tried to implement the above model

due to the following issues:

• For achieving highly accurate recommendations of learning contents, it is im-

portant to describe the learning status of a learner by his understanding of

each type of syntactic knowledge [37, 38]. Therefore, it is necessary to find

a way to exactly and logically describe each type of syntactic knowledge and

to automatically extract that syntactic knowledge which is included in the

common learner feedback.

• It is necessary to find a way to reconstruct the learning materials so that they

can be indexed and retrieved by the syntactic knowledge contained in the

materials.

3.2 SKP-based PEP

Syntactic Knowledge Point (SKP for short) is a way to describe the syntactic

knowledge contained in a program source code. Its details will be offered in later

Sections. SKP-based PEP is an approach to implement the PEP model mentioned

in Section 3.1 to address the issues in the existing implementations of PEP. Figure

3.2. SKP-based PEP 30

Figure 3.2: Model of SKP-based PEP. In (a) learning status is the learners’ un-derstanding of each type of syntactic knowledge (SKP), and in (b) the commonfeedback from a learner is shown.

3.2 shows the model of SKP-based PEP.

The learning materials are reconstructed as Learning topics via Learning topic

creation. There are two kinds of learning topic: Lecture topic and Exercise topic.

A lecture topic includes the following items:

• A segment of source code as an example program;

• A textual sentence related to the example program, such as the explanation

of the program.

An exercise topic corresponds to an exercise problem that includes the following

items:

• Textual explanations of a problem;

• The model answer code of the problem;

Learning topic creation indexes each learning topic by the SKP contained in an

example program or model answer source code.

3.3. Syntactic Knowledge Point (SKP) 31

SKP-based PEP collects two kinds of learner feedback: If the learner has read a

lecture topic, SKPs included in that topic will be collected; if the learner submitted

an answer source code for an exercise, SKPs included in the answer code with the

correct/incorrect status of the code will be collected. The collected data with the

learning activities is recorded into the learner’s Learning history by Learning

history creation.

The learning status of a learner is quantitatively estimated by learning status

estimation as his understanding of each type of syntactic knowledge (SKP), based

on his learning history.

Recommendation analyzes the SKP-based learning status and retrieves the

most appropriate learning topic(s) for the learner.

3.3 Syntactic Knowledge Point (SKP)

This section introduces the definition of SKP for C language, the relationship

between a type of SKP and Abstract Syntax Tree (AST for short), and the textual

expression of a type of SKP.

3.3.1 Definition of SKP

Types of SKP represent the smallest syntactic concepts included in C source

codes. For example, the following types of SKP exist in the variable declaration

statement of Listing 3.1

• Variable declaration in the compound statement;

• Data type token (int) in the variable declaration;

• Symbol “,” in the variable declaration;

• Variable name token (b) in the single variable declaration;

• Symbol “;” in the variable declaration.


Listing 3.1 An example of C program

1 #include <s t d i o . h>

2

3 int sum( int a , int b) {

4 return a + b ;

5 }

6

7 void main ( ) {

8 int a = 1 , b , m;

9 b = a + 2 ;

10 m = sum(a , b) ;

11 p r i n t f (”m=%d” , m) ;

12 }

3.3.2 SKP and AST

A program source code can be expressed by its Abstract Syntax Tree (AST for

short). In this dissertation, we mark each node in the AST with a token image

extracted from the source code as shown in Figure 3.3.

Figure 3.3: The Abstract Syntax Tree of Listing 3.1

Figure 3.3 also shows a type of SKP corresponding to a pair of parent-child nodes

in the AST, such as the 5 pairs of parent-child nodes indicated by red colored line


segments, which represent the types of SKP included in the variable declaration.

Each node in the AST has the following attributes:

• Node type: This represents the syntactic meaning of program code correspond-

ing to the subtree of this node, such as a symbol or an assignment expression;

• Local role: This represents the syntactic role of this node for its parent node.

For example, a node with node type of assignment expression may play a role

for an assignment statement, or for a For-statement as initialization or as a

counter increment/decrement.

Therefore, a type of SKP can be exactly represented by the combination of parent

node type, child node type and child node’s local role.

3.3.3 Textual Expression of SKP

In order to distinguish different types of SKP, it is necessary to identify the type

and local role of each node in the AST. The textual expression of node type and

local role are defined below:

• For every leaf node in the AST, the textual expression of its node type is the

token image of the node. However, there are two exceptions:

– Leaf nodes corresponding to user-defined function names have the same

node type, and their textual expressions are ID;

– Leaf nodes corresponding to variable names have the same node type,

and their textual expressions are ID.

Table 3.1 shows examples of leaf node types.

• For every inner node in the AST, the textual expression of the node type is

given based on the abbreviation for its syntactic definition. Table 3.2 shows

examples of inner node types.

• Since the local role of any node is only visible to its parent node, the role

can be defined by the parent node in a local definition. Here, the textual


Table 3.1: Examples of the textual expressions of leaf node types

Node type Textual expression

int intfloat floatmain mainvoid void( ({ {, ,; ;+ +user-defined variable name IDuser-defined function name IDlibrary function name the name of the function

Table 3.2: Examples of the textual expressions of inner node types

Node type Textual expression

function declaration DCFfunction header declaration DCFHvariable declaration DCVMcompose statement ST CMPexpression statement ST EXjump statement ST JMPassignment expression EX ASSbinomial expression EX BINfunction expression EX F

3.4. Algorithms in SKP-based PEP 35

expression of the role is defined as a serial number. Table 3.3 shows examples

of number of the role defined in function head declaration.

Table 3.3: Examples of the textual expression of the local role

Local role Textual expression

return-type 01function-name 02( 03) 04

Thus, for any node n, the textual expression of the type of SKP is given in the

format of {Tp R Tn}, where

• Tp: Textual expression of n’s parent node type;

• R: Textual expression of n’s local role;

• Tn: Textual expression of n’s node type.

Table 3.4 shows examples of SKP’s textual expression with the format above.

Table 3.4: Examples of SKP in function head declaration

Tp R Tn Textual expression of SKP Meaning

DCFH 01 int DCFH01int the return type (int)DCFH 02 ID DCFH02ID a user-defined function nameDCFH 03 ( DCFH03( the symbol “(” in function headDCFH 04 ) DCFH04) the symbol “)” in function head

3.4 Algorithms in SKP-based PEP

3.4.1 SKP Extraction and SKPV

SKP in a given C source code can be extracted by the following steps: (the

implementation of the extraction is shown in Appendix A)

1. AST of the source code is constructed by using a C parser;


2. Every node on the AST is recursively visited. And for each node, the textual

expressions of its node type, its local role and its parent’s node type are used

to form the textual expressions of types of SKP related to this node.

An SKP Vector (SKPV for short) is a set of types of SKP extracted from a C

program source code. Therefore, the syntactic knowledge included in a C program

can be described by its SKPV.

3.4.2 Learning Topic Database

Records in the learning topic database consist of lecture topic records and exer-

cise topic records. The format of a lecture topic record is as follows:

• topic identifer: It is related to the original learning materials such as lec01-1,

lec02-1. It can be created by an educator;

• program: An example program source code;

• segment: A segment of program;

• Data: The data for the standard input of program;

• Text: The textual explanation related to segment ;

• SKPV: The SKP Vector extracted from segment.

The format of an exercise topic record is as follows:

• topic identifer: It is related to the original learning materials such as ex01-1,

ex02-1. It can be created by an educator;

• program: A model answer program source code;

• data: The standard input data for checking the learner’s answer program;

• text: The textual statement of an exercise problem;

• SKPV: The SKP Vector extracted from the program.


3.4.3 Learning History Database

For a learner, there are two kinds of learning activities monitored, collected and

saved to the learner’s learning history records: When the learner has read a lecture

topic and executed the example program on the topic and when the learner has

submitted an answer source code for an exercise topic. The format of a learning

history record is as follows:

• skp: The type of SKP related to the learning activities of the learner;

• time: The timestamp of a learning activity;

• result: The learning activities related to a type of SKP. There are three types:

Read means that the learner has read a lecture topic that contains that type

of SKP; Correct means that the learner has submitted an answer source code

for an exercise topic, and the part of the code containing that type of SKP

was correct; Wrong means that the learner has submitted an answer code for

an exercise topic, and the part of the code containing that type of SKP was

wrong;

3.4.4 Learning Status Estimation

For an individual learner, his learning status is defined by his understanding level

of each type of SKP included in the learning topics that have been offered to him.

The learning status at time t can be estimated by the following steps:

1. Let K(t) be the set of types of SKP included in the learning history of the

learner at t.

K = {ki | 1 ≤ i ≤ Nk} (3.4.1)

Here, ki is a type of SKP and Nk is the length of K(t).

2. For a type of SKP k (k ∈ K), the learner’s understanding level u(k, t) at t is

estimated as:

u(k, t) = (A(k) + Y (k))/2 (3.4.2)


In formula 3.4.2, A(k) is the accuracy of k at t. Y (k) takes into consideration

the memory retention decline of k based on the Ebbinghaus forgetting curve

[46]. A(k) and Y (k) are computed as follows:

(a) A set of time periods, T is given, with days as the unites:

T = {Tj|1 6 j 5 N}

(b) For each Tj in T , the number of each type of result of k is extracted during

the last Tj days from the learning history of the learner, as follows:

• nr: the number of Read records

• nca: the number of Correct records

• nwa: the number of Wrong records

• ncac: the number of the last successive Correct records

(c) A(k)j for Tj is calculated as follows:

A(k)j = nca/(nca + nwa) (3.4.3)

, where 0 ≤ A(k)j ≤ 1.

(d) Y (k)j for Tj is calculated as follows:

Y (k)j = 1.84/[(log (te/n))1.25 + 1.84] (3.4.4)

,where:

• te is the elapsed time since the latest result of k was generated;

• n is the frequency that k appeared.

n = max(1,max((nca − nwa), ncac) + nr ∗ 0.6);

• 0 ≤ Y (k)j ≤ 1.

Formula 3.4.4 comes from [47]’s model of forgetting, which reveals the

change of retention of memory of a certain event over time. Here, there

are two changes in Formula 3.4.4 from the original model: (1) The in-

fluence of n has been considered (the larger n is, the more slowly Y (k)j

decreases); and (2) Y (k)j has been normalized to (0.0 ≤ Y (k)j ≤ 1.0).


(e) Finally, from each of the A(k)j and Y (k)j for each time period, the max-

imal A(k) and Y (k) are selected:

A(k) = max(A(k)j|1 6 j 6 N)

Y (k) = max(Y (k)j|1 6 j 6 N)

3. S(t), the learning status of the learner at t, is as follows:

S(t) = {ui|1 6 i 6 Nk} (3.4.5)

, where ui is the learner’s understanding level of ki.

3.4.5 Extraction of SKP with Poor Understanding

A type of SKP with poor understanding is one in which the learner’s under-

standing level of this type of SKP is less than a certain value.

Let R(t) be the set of types of SKP with poor understanding.

R(t) = {ki|ui < uc(t) ∩ 1 6 i 6 Nk} (3.4.6)

Here, uc(t) (0 ≤ uc(t) ≤ 1) is the criterion value used to judge whether the learner’s

understanding level of a type of SKP is poor. It can be set according to different

needs. For example, it could be set as the average of S(t) or it could be set as

the average of all learners’ understanding levels of the same type of SKP. In this

dissertation, we define uc(t) as in formula 3.4.7.

uc(t) =λ

Nk

Nk∑i=1

ui (3.4.7)

,where, λ (0.0 < λ < 1.0) is a parameter explained as follows: When λ = 1.0, uc(t)

is the average of S(t); and when λ is small enough, R(t) can be empty (R(t) = ∅).

Therefore, λ can be used by learners or programming educators to control the size

of R(t).


3.4.6 Learning Topic Recommendation

This procedure retrieves appropriate learning topic(s) for an individual learner

based on his K(t) and R(t).

In the case where R(t) = ∅, this means it is the beginning of learning to program

or the learner has high enough learning ability. Therefore, the learner needs to learn

a new learning topic. The policy for selecting a new topic with an SKP vector, V is

as follows:

• V \K(t) should not be empty (There should be new knowledge to learn in the

selected topic.);

• The size of V \K(t) should be small enough (There should not be too much

new knowledge to learn in the selected topic.);

• The size of V should be small enough (The selected topic should not include

too much knowledge that the learner has already understood.);

The procedure for retrieving the most appropriate topic(s) is as below:

1. For each learning topic LTi with SKPV, Vi in the learning topic database, mi

is extracted as shown below:

mi =

|K(t) ∩ Vi| (|Vi ∩K(t)| < |Vi|)

∞ (otherwise)

2. One or a group of learning topics are selected, such that mi is minimized.

3. In the case that only one learning topic is selected in the above step, it is

the most appropriate learning topic and the procedure terminates. In the case

that there are a group of topics selected, di for each learning topic in the group

is extracted as shown below:

di = |Vi|


Finally, the most appropriate topic(s) are the learning topics in the group with

di minimized.

In the case where R(t) 6= ∅, the learner needs to review some learning topics.

The policy for selecting a learning topic to review with SKP vector, V is as follows:

• The size of R(t) ∩ V should be large enough (The selected learning topic to

review should include as much knowledge as possible that the learner has

learned but has not understood.);

• The size of V should be small enough (The selected topic should not include

so much knowledge that the learner has already understood.);

• The size of V ∩ K(t) should be the size of V (The selected topic should not

include knowledge that the learner has not learned.);

The procedure of retrieving the most appropriate learning topic(s) is described be-

low:

1. For each topic LTi with SKPV, Vi in the learning topic database, mi is ex-

tracted as shown below:

mi =

−∞ (|Vi ∩K(t)| < |Vi|)

|Vi ∩R(t)| (otherwise)

2. One or a group of learning topics are selected, such that mi is maximized.

3. In the case that only one topic is selected in the above step, it is the most

appropriate topic and the procedure terminates. In the case that there are a

group of learning topics selected, di from the group of topics is extracted as

shown below:

di = 1− |Vi ∩R(t)|( fv|Vi|

+1− fv|R(t)|

)

3.5. Evaluation 42

Here, fv (0 6 fv 6 0.5) indicates the importance of the ratio of the intersection

between Vi and R(t). Finally, the most appropriate learning topic(s) are the

topics in the group with di minimized.

3.5 Evaluation

In order to verify the correctness of the algorithms proposed in Section 3.4,

experiments were carried out by simulations.

The following C program source codes were collected from a regular first-year

course, “Introduction of Programming” (mentioned in Section 2.3), taught in 2015:

• Example programs used in lectures;

• Model answers of exercise problems;

• Answers submitted by students for exercise problems.

The learning topic database is simulated as follows:

• Every example program is regarded as a lecture topic, and the SKPV of this

topic is extracted from the example program code;

• Every model answer is regarded as an exercise topic, and the SKPV of this

topic is extracted from the answer program code.

In the experiments, the attendance records and answer program code from four

students, si (i = 1, 2, 3, 4), were selected as analysis objects. In the term-end ex-

amination of the course, the order of students’ performances was s1 > s2 > s3 > s4.

Their learning history databases were simulated as follows:

• If si has attended a lecture, every type of SKP included in the lecture topics

related to that lecture was recorded with Read. The timestamp is the time

that the lecture was performed;

• If si has submitted a correct answer program for an exercise problem, every

type of SKP extracted from that program was recorded with Correct. The

timestamp is the time that si submitted the answer;

3.5. Evaluation 43

• If si has submitted an answer program with errors for an exercise problem,

every type of SKP extracted from the model answer program for that problem

was recorded with Wrong. The timestamp is the time that si submitted the

answer.

3.5.1 SKP Extraction

The types of SKP extracted from the example programs given in each lecture in

the course are shown in Figure 3.4. The top row shows lecture number, the leftmost

column shows the textual expressions of the types of SKP; and the colored cells

show the appearance of each type of SKP in each lecture.

Figure 3.4 shows that 215 kinds of SKP represent all C language syntactic knowl-

edge which needs to be learned by C beginners, including first-year university stu-

dents. This number is not too large for computer systems to handle.

An overview of C syntactic knowledge in each lecture is also shown in Figure

3.4, since the C syntactic concepts can be expressed by the combination of types of

SKP. For example, the basic structure of a C program and “printf()” function were

taught in the first lecture; integer type variable declarations, assignment statements

and “scanf()” functions were taught in lecture 2; double type variable declarations

were introduced in lecture 3; IF statements, conditional expressions and SWICH

statements were taught in lectures 4 and 5; FOR statements were taught in lecture

6; Arrays were taught in lecture 7; User defined functions were taught in lecture 13.

Figure 3.4 can also be used to check the validity of a teaching plan. For example,

“Type Casting” was taught in lecture 3 and had never been touched again in further

lectures.

3.5.2 Learning Status Estimation

For the four selected students, si (i = 1, 2, 3, 4), their understanding curves

of several typical SKP were estimated. The set of time periods, T , used in the

estimation: T = {21days, 120days}

The results are shown in Figure 3.5, where the X-axis is the time (days) and the

3.5. Evaluation 44

Figure 3.4: SKP distribution by lecture

3.5. Evaluation 45

(a) (b)

(c) (d)

Figure 3.5: Estimated understanding of particular types of SKP for the first100 days. (a) is for “DCFH02main”, (b) is for “EX F05EX URY”, (c) is for“ST CMP04ST IF” , and (d) is for “EX BIN82double”.

y-axis is the students’ understanding level of a particular type of SKP.

• Figure 3.5(a) shows the understanding curves of DCFH02main which rep-

resents the main function name. DCFH02main is the most basic syntax for

constructing a C program. Since this type of SKP was included in every com-

pleted C program and was touched on in every lecture and exercise, it was well

understood. For all the four students, their understanding levels of this type

of SKP were all high. The reason s1’s value was low at the beginning of the

course was that in one answer source code submitted by s1, the name of the

main function was wrong. In addition, the reason that s4’s value was low over

the period was that s4 had not submitted his answer source code for several

exercises;

• Figure 3.5(b) shows the understanding curves of EX F05EX URY which

represents a unary expression used in a function expression as an argument.

3.5. Evaluation 46

EX F05EX URY is similar to DCFH02main. It was early introduced in lec-

ture 2, and was then repeated in subsequent lectures, thus it became well

understood;

• Figure 3.5(c) shows the understanding curves of ST CMP04ST IF which

represents an IF statement. ST CMP04ST IF had appeared in each lecture

and exercise since it was firstly introduced in lecture 4. s1’s understanding

value was very high. The other students had not completed or not submit-

ted their answers for some problems which needed to be solved by using IF

statements, thus their values were lower than s1.

• Figure 3.5(d) shows the understanding curves of EX BIN82double which

represents a cast double value used in a binomial expression. Though this

one was introduced early, it was not repeated enough, and so it was only well

understood by s1.

Table 3.5 shows the distribution of the four students’ understanding levels of

all types of SKP on the 110th day (the last day of the course). The frequency in

the left column refers to the number of types of SKP that are distributed in the

corresponding range of understanding level. s1’s understanding level of over 90%

of types of SKP is higher than others. Thus s1 is the best learner among the four

students and the order of understanding level is s1 > s2 > s3 > s4. This is the same

as the order of their term-end examination scores.

3.5.3 Extraction of SKP with Poor Understanding

As an example, from s4’s learning status over the 110 days, all SKPs with an

understanding level less than 0.3 were extracted, as shown in Table 3.6. Since each

type of SKP can be considered as a relation between a node and its parent in the

AST, the types of SKP in Table 3.6 can be grouped based on the relation as shown

in Figure 3.6.

Figure 3.6 indicates that s4’s weak points in C language syntax are function

declaration, FOR/IF statements and assignment expression. Table 3.6 also gives

details about those weak points.

3.5. Evaluation 47

Table 3.5: Distribution of students’ understanding level

Range of understanding levelFrequency

s1 s2 s3 s4

[0.0, 1.0) 2 5 15 17[0.1, 0.2) 0 2 5 2[0.2, 0.3) 0 4 26 15[0.3, 0.4) 0 6 4 16[0.4, 0.5) 0 3 4 5[0.5, 0.6) 44 47 54 47[0.6, 0.7) 20 23 26 40[0.7, 0.8) 31 44 53 39[0.8, 0.9) 22 52 49 55[0.9, 1.0) 117 50 0 0

(a) (b) (c)

Figure 3.6: Groups of s4’s types of SKP with poor understanding, where (a) showsthe types of SKP related to function declaration, (b) shows the types of SKP re-lated to FOR/IF statements, and (c) shows the types of SKP related to assignmentexpression.

3.5. Evaluation 48

Table 3.6: s4’s SKP with poor understanding on the 110th day

Type of SKP Meaning

EX BIN61( the symbol “(” in a binomial expressionEX BIN62) the symbol “)” in a binomial expressionEX V81( the symbol “(” in a casting variableEX V82double double type in a casting variableEX V83) the symbol “)” in a casting variableEX V01ID a variable in an expressionEX URY01 the symbol “-” in a unary expressionEX URY02EX CST a constant in a unary expressionDCV07EX URY a unary expression as a variable initializerEX BIN81( the symbol “(” in a casting binomial expressionEX BIN82double casting double type in an expressionEX BIN83) the symbol “)” in a casting binomial expressionEX ASS03EX URY a unary expression in an assignment expressionST IF07ST EX an expression statement in an IF statementEX BIN01EX F a function call in a binomial expressionEX BIN01EX PDF a predefined macro used in left side of a binomial expressionST FOR09ST EX a statement in a FOR statementEX ASS61( the symbol “(” in an assignment expressionEX ASS62) the symbol “)” in an assignment expressionEX CND01EX ASS an assignment expression in a conditional expressionDCFH01double the return type (double)DCAG01double the argument type (double)ST JMP03EX V a variable in a return statementDCAG01int the argument type (int)EX ASS02*= the symbol “*=” in an assignment expressionDCFH01void the return type (void)EX BIN03EX F a function call in a binomial expressionDCFH05, the symbol “,” in a function declarationEX F01sqrt a function call of sqrt()ST JMP03EX F a function call in a return statementST FOR07EX ASS a variable update in a FOR statementEX BIN03EX PDF a predefined macro used in the right side of a binomial expressionEX BIN82int the int type used in a casting binomial expressionDCV07EX PDF a predefined variable as a variable initializerST EX01EX BIN a binomial expression in an expression statementDCV03EX BIN a binomial expression in an array declaration

3.5. Evaluation 49

3.5.4 Learning Topic Recommendation

Since the learning topic recommendation is based on the estimation of m and d

for each topic, estimation algorithms for m and d were verified.

(a)

(b)

Figure 3.7: m and d calculated for each lecture topic, based on s1’s learning status(λ = 0, R(t) = Ø). (a) shows the results on the 31st day, and (b) shows the resultson the 80th day.

Figure 3.7 presents the values of m and d for each lecture topic with the SKPV

extracted from an example program, based on s1’s K(t) and R(t) in the case where

λ = 0 and t is the 31st day and the 80th day. The vertical axis shows the values of

m and d; the horizontal axis represents lecture topics. m is shown by the green line

and d is shown by the blue line. From Figure 3.7, the following can be understood:

• The changes of m and d are similar. This means that in each lecture topic,

the quantity of new SKPs is proportional to the quantity of the total SKPs.

• On the 31st day and the 80th day, there is a topic with a unique minimum m.

3.5. Evaluation 50

Therefore, for extracting the most appropriate learning topic, d is an optional

parameter, as it’s not used in this example.

(a)

(b)

Figure 3.8: m and d calculated for each lecture topic on the 80th day (λ = 1, R(t) 6=Ø). (a) shows the results based on the learning status of s1, and (b) shows theresults based on the learning status of s4.

Figure 3.8 shows the values of m and d for each lecture topic, based on K(t) and

R(t) of s1 and s4 in the case where λ = 1 and t is the 80th day. The left vertical

axis shows the values of d, the right shows the values of m. The horizontal axis

represents lecture topics. m is shown by the green line and d is shown by the blue

line. From Figure 3.8, s1’s m and d are much lower than s4. This means that s1’s

learning status is much better than s4, and s1 has fewer lecture topics to learn.

Chapter 4

Conclusion

This research focused on solving the issues in the existing education environment

for computer programming and proposed two support methods, Lecture Oriented

Program Visualization tool (LOPV tool) and Syntactic Knowledge Point based Per-

sonalized E-learning for Programming (SKP-based PEP), for promoting computer

programming beginners’ understanding of computer language and concepts in lec-

ture, exercise and self-study.

LOPV tool is a new concept that offered a new avenue of research on computer

programming learning support. LOPV tool aims at promoting students’ under-

standing of program concepts given in CS1 lectures, by seamlessly being combined

with instructor’s action and existing teaching materials. In this research, an ap-

proach to improve existing educational PV tools to be lecture oriented was given

and confirmed by an experimental implementation of LOPV tool – PROVIT (PRO-

gram VIsualization Tool). Furthermore, the significance and importance of LOPV

on enhancing lectures on programming were confirmed by a two-year application ex-

periment with PROVIT in a regular computer programming course. This research

is only the beginning of LOPV. In the future, refined LOPV tools with well-designed

user interface, more conveniences to instructors, PV techniques for more program

concepts and languages are expected.

SKP is a new way to quantitatively and precisely represent syntactic information

included in program source code. This research gives algorithms to extract SKP from

program, estimate students’ SKP-based understanding of program language from

51

Chapter 4. Conclusion 52

students’ feedback, analysis students’ SKP-based learning status, and recommend

appropriate learning contents to individual student. All those algorithms are the

basis to construct an adaptive learning environment that all processing steps of it

can be fully handled by computer system. SKP has other important features such

as learning materials design support by checking the rationality of the knowledge

distribution in learning materials in a more convenient way and independence of

computer languages.

Computer programming skill is very important to the development of informa-

tion society. Experience of computer programming is useful and effect to enhance

human’s ability such as logical thinking. It is expected that the results obtained at

this research can benefit the educational activities on computer programming. On

the other hand, with the development of ICT such as AI (Artificial Intelligence) and

VR (Virtual Reality), it can be expected that education environment of computer

programming will progress in the near future and research on educational support

methods for programming will enter the next stage.

Bibliography

[1] H. Tsukamoto, Y. Takemura, H. Nagumo and N. Nitta, “Work in progress:

analysis of the relationship between teaching contents and motivation in pro-

gramming education”, Proc. of frontiers in education conference, pp. 1-2, Seat-

tle WA USA, February 2013.

[2] H. Tsukamoto, Y. Takemura, H. Nagumo, I. Ikeda, A. Monden and K. Mat-

sumoto, “Programming education for primary school children using a textual

programming language”, Proc. of frontiers in education conference, pp. 1-7,

EI Paso TX USA, October 2015.

[3] C. Watson and F. W. B. Li, “Failure rates in introductory programming re-

visited”, Proc. of 2014 conference on innovation and technology in computer

science education, pp. 21-25, Uppsala Sweden, June 2014.

[4] A. Eckerdal and M. Thune, “Novice Java programmers’ conceptions of object

and class, and variation theory”, ACM sigchi bulletin, Vol. 37(3), pp. 89-93,

2005.

[5] S. Booth, “Learning to program: a phenomenographic perspective”, doctoral

dissertation, University of Gothenburg, 1992.

[6] J. Sorva, V. Karavirta and L. Malmi, “A review of generic program visualiza-

tion systems for introductory programming education”, ACM transctions on

computer education, Vol. 13(4), pp. 15:1-15:64, 2013.

[7] K. Shigeta, K. Uehara and J. Murai, “Questionnaire survey and analysis of

curriculum ‘information’ in japanese high school”, information processing so-

ciety of Japan, pp. 31-38, 2015.

53

Bibliography 54

[8] M. Olsson, P. Mozelius and J. Collin, “Visualisation and gamification of e-

Learning and programming education”, electronic journal of e-Learning, Vol.

13(6), pp. 441-454, 2015.

[9] B. A. Price, R. M. Baecker and I. S. Small, “A principled taxonomy of software

visualization”, journal of visual languages & computing, Vol. 4(3), pp. 211-266,

1993.

[10] K. M. Ala-Mutka, “A survey of automated assessment approaches for pro-

gramming assignments”, computer science education, Vol. 15(2), pp. 83-102,

2005.

[11] P. Brusilovsky, “Adaptive educational hypermedia”, Proc. of the tenth inter-

national PEG conference, pp. 8-12, Tampere Finland, June 2001.

[12] C. Douce, D. Livingstone and J. Orwell, “Automatic test-based assessment of

programming: a review”, ACM journal of educational resources in computing,

Vol. 5(3), pp. 4:1-4:13, 2005.

[13] S. Cooper, W. Dann and R. Pausch, “Using animated 3d graphics to prepare

novices for CS1”, computer science education, Vol. 13(1), pp. 3–30, 2003.

[14] S. Xinogalos, M. Satratzemi and V. Dagdilelis, “An introduction to object-

oriented programming with a didactic microworld: objectKarel”, computers

and education, Vol. 47(2), pp. 148-171, 2006.

[15] B. A. Myer, “Visual programming, programming by example, and program

visualization: a taxonomy”, ACM sigchi bulletin, Vol. 17(4), pp. 59-66, 1986.

[16] M. C. Jensen, “Eclipse of the public corporation”, harvard business review,

1997.

[17] T. Boudreau, J. Glick, S. Greene, V. Spurlin and J. J. Woehr, “NetBeans: the

definitive guide: developing, debugging, and deploying Java code”, O’Reilly

Media, Inc., 2002.

Bibliography 55

[18] G. Ebel and M. Ben-Ari, “Affective effects of program visualization”, Proc. of

the second international workshop on computing education research, pp. 1-5,

Canterbury UK, September 2006.

[19] A. Pears, S. Seidman, L. Malmi, L. Mannila, E. Adams, J. Bennedsen, M.

Devlin and J. Paterson, “A survey of literature on the teaching of introductory

programming”, ACM sigcse bulletin, Vol. 39(4), pp. 204 - 223, 2007.

[20] M. P. Bruce-Lockhart and T. S. Norvell, “Lifting the hood of the computer:

program animation with the teaching machine”, Proc. of IEEE canadian

conference on electrical and computer engineering, pp. 831-835, Halifax NS

Canada, May 2000.

[21] A. T. Virtanen, E. Lahtinen and H. M. Jarvinen, “VIP, a visual interpreter for

learning introductory programming with C++”, Proc. of the fifth koli calling

conference on computer science education, pp. 125-130, Turku Finland, 2005.

[22] A. Moreno, N. Myller, E. Sutinen, and M. Ben-Ari, “Visualizing programs

with Jeliot 3”, Proc. of working conference on advanced visual interfaces, pp.

373-376, Gallipoli Italy, May 2004.

[23] N. Myller, R. Bednarik and A. Moreno, “Integrating dynamic program visu-

alization into BlueJ: the Jeliot 3 extension”, Proc. of the seventh IEEE inter-

national conference on advanced learning technologies, pp. 505-506, Niigata

Japan, July 2007.

[24] O. Kannusmaki, A. Moreno, N. Myller and E. Sutinen, “What a novice wants:

students using program visualization in distance programming course”, Proc.

of the third program visualization workshop, pp. 126-133, Coventry UK, July

2004.

[25] N. Myller, R. Bednarik and E. Sutinen, “Extending the engagement taxon-

omy: software visualization and collaborative learning”, ACM transactions on

computing education, Vol. 9(1), pp. 7:1-7:27, 2009.

Bibliography 56

[26] E. Kaila, T. Rajala, M. J. Laakso and T. Salakoski, “Effects of course-long use

of a program visualization tool”, Proc. of the twelfth australasian conference

on computing education, pp. 97-106, Brisbane Australia, January 2010.

[27] J. Sorva and T. Sirkia, “UUhistle: a software tool for visual program simu-

lation”, Proc. of the tenth koli calling international conference on computing

education research, pp. 49-54, Turku Finland, October 2010.

[28] T. Sirkis and J. Sorva, “Exploring programming misconceptions: an analysis of

student mistakes in visual program simulation exercises”, Proc. of the twelfth

koli calling international conference on computing education research, pp. 19-

28, Turku Finland, November 2012.

[29] J. Helminen and L. Malmi, “Jype - a program visualization and program-

ming exercise tool for Python”, Proc. of the fifth international symposium on

software visualization, pp. 153-162, Salt Lake City Utah USA, October 2010.

[30] P. J. Guo, “Online python tutor: embeddable web-based program visualization

for CS education”, Proc. of the 44th ACM technical symposium on computer

science education, pp. 579-584, Denver Colorado USA, March 2013.

[31] B. Perter, “Adaptive hypermedia: from intelligent tutoring systems to web-

based education”, Proc. of the fifth international conference on intelligent

tutoring systems, pp. 1-7, Montreal Canada, June 2000.

[32] P. De Bra, “Adaptive educational hypermedia on the web”, communications

of the ACM - the adaptive web, Vol.45(5), pp. 60-61, 2002.

[33] I. H. Hsiao, S. Sosnovsky and P. Brusilovsky, “Guiding students to the right

questions: adaptive navigation support in an e-learning system for Java pro-

gramming”, journal of computer assisted learning, Vol. 26(4), pp. 270-283,

2010.

[34] A. K. Milicevic, B. Vesin, M. Ivanovic and Z. Budimac, “E-learning personal-

ization based on hybrid recommendation strategy and learning style identifi-

cation”, computers & education, Vol.56(3), pp. 885-899, 2011.

Bibliography 57

[35] H. Taguchi, H. Itoga, K. Mouri, T. Yamamoto and H. Shmakawa, “Program-

ming training of students according to individual understanding and attitude”,

information processing society of Japan, Vol. 48(2), pp. 958-996, 2007.

[36] C. Pahl and C. Kenny, “Interactive correction and recommendation for com-

puter language learning and training”, IEEE transactions on knowledge and

data engineering, Vol. 21(6), pp. 854-866, 2009.

[37] K. Chrysafiadi and M. Virvou, “Dynamically personalized e-training in com-

puter programming and the language C”, IEEE transactions on education,

Vol. 56(4), pp. 385-392, 2013.

[38] K. Chrysafiadi and M. Virvou, “K. E. M. Cs: A set of student’s characteristics

for modeling in adaptive programming tutoring systems”, Proc. of the fifth

international conference on information, intelligence, systems and applications

conference, pp.106-110, Chania Greece, August 2014.

[39] V. G. Renumol, S. Jayaprakash and D. Janakiram, “Classification of cognitive

difficulties of students to learn computer programming”, indian institute of

technology, 2009.

[40] T. Rajala, M. J. Laakso, E. Kaila and T. Salakoski, “VILLE: a language-

independent program visualization tool”, Proc. of the seventh baltic sea con-

ference on computing education research, pp. 151-159, Koli National Park

Finland, November 2007.

[41] A. He, “C virtual machine for educational program visualization for begin-

ners”, IEICE transactions on information and systems, Vol. J98-D(10), pp.

1292-1300, 2015.

[42] S. Mace, “Presentation package lets users control look”, infoworld, Vol. 9(9),

pp. 5, 1987.

[43] https://httpd.apache.org, 2017

[44] J. Zukowski, “Deploying software with jnlp and java web start”, technical

article, 2002.

Bibliography 58

[45] http://cleast.u-aizu.ac.jp, 2017

[46] H. Ebbinghaus, “Memory: a contribution to experimental psychology”, Uni-

versity Microfilms, No. 3, 1913.

[47] T. Fukami, “Ebbinghaus’s forgetting curve and its model function”, Proc. of

the 78th annual convention of the Japanese psychological association, Kyoto

Japan, September 2014.

[48] Matamata, “JavaCC”, [online] https://javacc.java.net/ (accessed 25 May

2016).

[49] D. South, “C Grammar Definition for Use with JavaCC”, [online]

https://java.net/downloads/javacc/contrib/grammars/C.jj (accessed 25 May

2016).

Appendix A

Implementation of SKP

Extraction

A C-parser is the core part of the implementation for SKP extraction. The

Java code of the C-parser is generated by using JavaCC (Java Compiler Compiler)

[48], which compiles the C grammar definition file extended from Doug South’s

contribution [49].

Listing A.2 is an example of extending Doug South’s definition (shown in listing

A.1) for a WHILE statement and a FOR statement.

Listing A.1 Doug South’s original definition

1 void I t e ra t i onSta tement ( ) : {}

2 {

3 (

4 <WHILE> ”(” Express ion ( ) ”)”

5 Statement ( )

6 |

7 <FOR> ”(” [ Express ion ( ) ] ” ; ”

8 [ Express ion ( ) ] ” ; ”

9 [ Express ion ( ) ] ”)”

10

11 Statement ( ) )

12 }

59

Chapter A. Implementation of SKP Extraction 60

Listing A.2 Extended definition

1 CVStatement I t e ra t i onSta tement ( ) : {

2 CVExpressionEx e i , e c , e r ;

3 CVStatementEx s , s b ;

4 CVMSymbol p t l ; CVMSymbol ptr ;

5 CVMSymbol sc1 , sc2 ;

6 CVMSymbol s i ;

7 }

8 {

9 (

10 <WHILE> { s i = new CVMSymbol( token ) ;}

11 ”(” { p t l = new CVMSymbol( token ) ;}

12 e c = Express ion ( )

13 ”)” {ptr = new CVMSymbol( token ) ;}

14 s b = Statement ( )

15 { s = new CVWhileStatementEx ( s i ,

16 pt l , e c , ptr , s b ) ;}

17 |

18 <FOR> { s i = new CVMSymbol( token ) ;}

19 ”(” { p t l = new CVMSymbol( token ) ;}

20 [ e i = Express ion ( ) ]

21 ” ; ” { sc1 = new CVMSymbol( token ) ;}

22 [ e c = Express ion ( ) ]

23 ” ; ” { sc2 = new CVMSymbol( token ) ;}

24 [ e r = Express ion ( ) ]

25 ”)” {ptr = new CVMSymbol( token ) ;}

26 s b = Statement ( )

27 { s = new CVForStatementEx ( s i , pt l ,

28 e i , sc1 , e c , sc2 , e r , ptr ,

29 s b ) ;}

30 )

31 { re turn s ;}

32 }

As shown above, the extended definition adds Java code to Doug South’s def-

inition to create an AST where every node is an object of a certain kind Java

Chapter A. Implementation of SKP Extraction 61

class: CVMSymbol represents a symbol; CVExpressionEx represents an expression;

CVStatementEx represents a statement; CVWhileStatementEx represents a WHILE

statement; and CVForStatementEx represents a FOR statement. The nodes of AST

are all subclasses of CVMNode.

For extracting SKP, every node implements the following methods:

• getNodeType() gives the textual expression of its node type;

• getChildRole(CVMNode c) gives the textual expression of the local role of its

child c;

• getSKPID() gives the textual expression of a type of SKP related to this node.

For each input of source code, this function also gives the number of instances

of each type of SKP in the source code.

Documents

Programming Learning Support Methods based on Adaptive