Content uploaded by Ethel Tshukudu
Author content
All content in this area was uploaded by Ethel Tshukudu on Jun 06, 2020
Content may be subject to copyright.
Semantic Transfer in Programming Languages: Exploratory
Study of Relative Novices
Ethel Tshukudu
University of Glasgow
Glasgow, UK
ethel.tshukudu@glasgow.ac.uk
Quintin Cutts
University of Glasgow
Glasgow, UK
quintin.cutts@glasgow.ac.uk
ABSTRACT
It is a natural part of a student
'
s computing education to transfer
from language to language, hence adopting to a new programming
language (PL) quickly is a necessary skill. Prior work in computer
science research mainly brings awareness of the success and di-
culties that students face when learning new languages. In addition,
work that directly relates to PL transfer mainly concerns experi-
enced programmers problem solving in a new language, evidencing
plan transfer. We could not nd research attempting to devise a
model of PL transfer based on code comprehension. We explore this
phenomenon in the context of ve university students transitioning
from procedural Python to object-oriented Java, over a period of 10
weeks. We analyse the results through the lens of a model of second
language acquisition using the notion of Semantic transfer and the
Mindshift learning theory (MLT). The ndings indicate that during
the initial learning stages, learners relied mostly on their syntactic
matching between Python and Java and subsequent semantic trans-
fer which aected their learning positively on Carryover concepts
and negatively on Changed concepts. Students could not transfer
their semantic knowledge on concepts they perceived as Novel. An
understanding of the transfer process learners go through during a
shift can help inform our pedagogy on how to ease the transition
process and achieve an eective learning process, and we provide
pointers in this direction.
CCS CONCEPTS
•Social and professional topics →Computer science educa-
tion.
KEYWORDS
programming language concepts; transfer; code comprehension;
syntax; semantics; Java; Python
ACM Reference Format:
Ethel Tshukudu and Quintin Cutts. 2020. Semantic Transfer in Programming
Languages: Exploratory Study of Relative Novices. In Proceedings of the
2020 ACM Conference on Innovation and Technology in Computer Science
Education (ITiCSE ’20), June 15–19, 2020, Trondheim, Norway. ACM, New
York, NY, USA, 7 pages. https://doi.org/10.1145/3341525.3387406
Permission to make digital or hard copies of all or part of this work for personal or
classroom use is granted without fee provided that copies are not made or distributed
for prot or commercial advantage and that copies bear this notice and the full citation
on the rst page. Copyrights for components of this work owned by others than ACM
must be honored. Abstracting with credit is permitted. To copy otherwise, or republish,
to post on servers or to redistribute to lists, requires prior specic permission and/or a
fee. Request permissions from permissions@acm.org.
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
©2020 Association for Computing Machinery.
ACM ISBN 978-1-4503-6874-2/20/06. . . $15.00
https://doi.org/10.1145/3341525.3387406
1 INTRODUCTION
A key skill of any competent computer scientist or software engi-
neer is to be able to adopt new programming languages (PL) quickly.
Furthermore, it is a natural part of a student’s computing education
to transfer from language to language. For example, an elemen-
tary school pupil is likely to use a block-based language such as
Scratch or Alice and then move on to a text-based language later
in secondary school. They may then transfer from one paradigm to
another, for example, procedural to object-oriented (OO), or to a
functional language. University students must pick up a wide array
of languages as they progress with their education.
Recognising the importance of PL transfer, this paper reviews the
literature, nding that it mainly concerns problem solving transfer
for experienced programmers. For such programmers, the main
concern in transferring to a new language is the way in which
their programming plans or patterns must be adjusted to suit a new
language with unfamiliar concepts and constructs.
This leaves a crucial gap concerning how PL transfer happens
during code comprehension, in line with the focus in recent years
on program comprehension as key to learning programming, e.g.
[
20
,
21
]. Unlike prior work, this study will focus especially on
relative novices, often only with a limited grasp of PL concepts and
skills, compared to an experienced programmer. We are particularly
interested in exploring the following question:
•
How do students transfer their programming language con-
ceptual knowledge to a new language during code compre-
hension?
This paper contributes to existing work by providing the initial
understanding of PL transfer process of relative novices during
code comprehension. It presents an in-depth case study of ve un-
dergraduate students transitioning from procedural Python to OO
Java. The study asks the participants to explain their understanding
of Python and Java programs. These explanations are analysed
through the lens of the contributions of key papers drawn from
both programming language[
1
] and natural language[
7
] transfer
domains. The ndings indicate that during initial stages of learning
a new language students make syntax matches between the prior
language and the new language and subsequent semantic transfer.
The paper is structured as follows: Section 2 contains the litera-
ture review and presents the key papers driving the study presented
in Section 3 and the nal sections provides recommendations for
instructors, and conclusions.
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
307
2 RELATED WORK
In this section we summarize the research in programming lan-
guage transfer which touches on both the transition challenges and
cognitive aspects of programming language transfer.
2.1 Relative novice transition problems
Several empirical studies were carried out on transitioning from
block-based languages to text-based languages on relative novices.
Kolling summarised the concepts causing transition challenges [
9
]:
method calls, parameter passing, return values, variable assign-
ments, data types, expressions. Other studies that identied similar
challenges are [
14
,
34
,
35
]. Attempts to address these transition
issues mostly create tools to support interfaces with both visual
and corresponding text language for students to form analogies at
the text surface (syntax) as they transition [3, 6, 9, 36].
Other studies have focused on transition between dierent tex-
tual languages. For example, Walker et al. [
32
] investigated students
who were transitioning from Pascal to Ada. They reported that stu-
dents tend to be biased towards using familiar constructs from the
prior language rather than new constructs in Ada when solving
programming problems in their assignments.
Another area of research was interested on investigating tran-
sitioning between dierent paradigms and reported a number of
challenges. For example, Nelson et al. investigated participants
who ranged from relative novice to expert procedural program-
mers learning the OO paradigm using Small-talk for the rst time
over four months [
12
]. They discovered that unlike experienced
programmers who had a background with multiple paradigms, rel-
ative novices struggled with learning objects at the initial stages
of learning, however they could connect familiar constructs like
loops and branching to their procedural knowledge.
The researchers above conrm that novices face diculty trans-
ferring to new languages, but they do not explore the cognitive
processes that are involved. Study of such processes have been car-
ried out but mainly in the context of problem solving strategies of
experienced programmers. This research is now explored in section
2.2.
2.2 Experienced programmers transfer via
problem solving
Anderson et al. [
37
] studied six programmers who demonstrated
positive algorithmic plan transfer between Lisp and Prolog and
eight programmers who transferred between Lisp and Pascal. On
the other hand, Scholtz and Wiedenbeck reported both positive
and negative transfer by programmers developing programs in a
new language. Positive plan structure transfer from Pascal was
observed when programmers solved a string reversal problem in
Ada, while the transfer from Pascal to Icon was negative because
subjects used a character-oriented plan structure inappropriate for
Icon. In addition to these ndings, their other study [
16
] video-
taped ve experienced programmers with C and Pascal experience
planning in the new Icon language, showing that programmers use
familiar plans in the known language when they begin to program
in a new language, most often resulting in negative transfer. They
also reported that while developing plans, the programmers made
assumptions based on the syntax similarities of the prior language
and the new language [
18
,
24
,
32
]. Scholtz et al. [
17
] developed a
model for planning in a new language, showing that programmers
make many plan changes as they write a program in a new language
[17].
These studies shed light on the cognitive process of experienced
programmers learning to solve problems in a new language. How-
ever, they have not put emphasis on the other crucial area of learn-
ing programming besides problem solving, which is code compre-
hension in line with more recent thinking about language learn-
ing [
21
]. In addition, these studies give little attention to novice
programmers who have limited knowledge of plans for solving
programming problems. Such programmers tend to focus more on
the syntactic structure of a programming language[1, 27, 28].
2.3 Starting point for relative novice transfer
via code comprehension
To analyze the cognitive processes behind code comprehension,
researchers have developed several code comprehension models
[
23
,
31
], however these existing models give little attention to com-
prehending code in a second or subsequent programming language.
This is a gap this research aims to ll in the existing work. As our ini-
tial starting point, we aim to study the code comprehension process
of a relative novice programmer transferring to a new program-
ming language. We are particularly interested in the relative novice
because we believe that if we become better at understanding their
code comprehension process in a new language, we will become
better at accounting for the success and failure of language transfer
in the teaching and learning of new programming languages which
has become the norm in CS curricula.
2.4 Theoretical Framework
Our research will draw upon the Mindshift Learning Theory by
Armstrong et al. [
1
]. This model is not based on PL transfer of code
comprehension. However, it was developed based on conceptual
knowledge transfer in the context of professional programmers
transitioning from non-OO to OO software development. The model
proposes three categories of transfer that engage the programmer
in cognitive processing as they transition to a new paradigm:
•
A Carryover concept is a concept with similar meaning in
the old and new contexts.
•
A Changed concept is similar to a known concept but has a
dierent meaning in the new context.
•
A Novel concept is a concept not already known to the
learner.
Outside the CS focus, we recognise some of the natural language
transfer models based on learning a second natural language. Nat-
ural languages are clearly related to Programming Languages, as
evidenced in functional Magnetic Resonance Imaging (fMRI) studies
which conclude that they both activate the syntactic and semantic
regions of the brain [
13
,
26
]. In addition to the MLT we will also
draw from Jiang
'
s second language acquisition model [
7
,
8
] based
on a notion of semantic transfer and consisting of three stages:
(1)
Stage 1 (Word Association Stage): A lexical association be-
tween Language 2 (L2) word and its Language 1 (L1) transla-
tion happens when a L2 lexical entry (e.g. a word) is intro-
duced to the learner.
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
308
(2)
Stage 2(Lemma Mediation Stage): The word is then associ-
ated with the L1 which already exists in the learner’s knowl-
edge structure and, crucially, its semantic meaning is trans-
ferred from L1 to L2.
(3)
Stage 3(Full Integration Stage): Finally, continued exposure
to contextualised word input in L2 helps to develop L2 se-
mantic context in the knowledge structure such that the
dependency on the meaning of the L1 is weakened.
3 RESEARCH STUDY
3.1 Method
The research that is the clear antecedent to this study has used
qualitative methods with a small sample size to explore the issue
of transfer [
16
–
19
]. Guided by this prior work, we use a qualitative
exploratory case study approach. This method is used to come to
an educated initial perception of what is going on in a situation
by studying a few instances of a phenomenon in depth [
5
]. The
results of the study do NOT intend to make generalized claims
but to gain a rich understanding of the underlying process of PL
transfer for students which is lacking in existing research. We
believe this will provide insights into the phenomenon and help
develop a hypotheses for potential quantitative research. As a lter
to organise collected data[
30
], the results will be analysed through
the lens of second natural language acquisition model based on
semantic transfer [
7
,
8
] and programming languages Mindshift
Learning Theory [1].
3.1.1 Participants. Five students enrolled in a second year uni-
versity Introduction to Java class having never used Java before:
participants P1-P5. They had two levels of prior expertise: four had
studied only Alice and non-OO or "procedural" Python in their rst
year, referred to as novices hereafter; one participant, P5, was an
expert with 6 years of Python, C and C++ experience. Although
the sample size might seem too small, it should be noted that this
research is a qualitative study that is not aiming to give statistical
analysis but explore how transfer works within a small population.
3.1.2 The course. The course runs for 11 weeks, 2 lectures and
a lab each week. It pays limited attention to connecting the Java
concepts back to those learned in Python, expecting that a good
understanding of programming concepts will be enough.
3.1.3 The intervention. Students were tracked over a period of 10
weeks via six 1-hour fortnightly individual interviews conducted
by one of the authors. Students were asked to
•
carry out code comprehension exercises in Python and Java,
describing their thoughts and actions as they did so, and
•
(from the second session) note their condence with the
concepts/constructs currently being studied.
All discussions were recorded and transcribed by both the au-
thors; the study materials are available from the authors on re-
quest. The transcriptions directed our study activities, with each
fortnightly group of interviews being informed by analysis of the
previous interviews, these will be presented as sessions. We used
the micro-genetic research method [
25
] which is used to assess
1public class Rectangle {
2int length=3;
3int width=4;
4public static void main(String args[]) {
5Rectangle r1=new Rectangle();
6r1.insert(12,4);
7}
8public int insert(int l, int w) {
9int result=l*w;
10 if (l > w)
11 System.out.println("The answer is " + l*w);
12 else
13 System.out.println("no result");
14 return result;
15 }
16 }
Listing 1: Java Program used in session 1
progress in understanding cognitive developmental change mecha-
nisms. It is a method well used in computer science research [
29
].
It involves:
•
observations of individual students throughout the period
of the change,
•
a high density of observations relative to the rate of change
within that period, and
•
intensive trial-by-trial analyses intended to infer the pro-
cesses that gave rise to the change.
Because of the size limitation of the paper, we report only 3
sessions which are; session 1(carried out before Java), session 2
(week 2 into Java) and session 4 (week 6 into Java). These sessions
were chosen because they represented all the three categories of
the MLT and they also showed misconceptions students have in
a new language during transfer. We identied recurring patterns
of students learning a new language from their audio-recordings.
The results are presented per session and each session contains
a particular student case study that was similar to other student
cases in that session. This kind of results analysis has been used in
other computer science qualitative research [10, 22]
3.2 Session 1
Initially, we assessed the participants
'
comprehension of Java, to
which they had had no prior exposure. We chose a simple program
to calculate the area of a rectangle (Listing 1), because it includes
common constructs shared by Python and Java such as variable
declarations, parameter passing, subprograms and calls, and if-
statements. Some constructs were not shared, such as classes and
objects. Participants were asked to talk through as they carried out
the program comprehension task, and then give the output of the
program.
3.2.1 Results.
Student P2 performed this think aloud code comprehension task
on the Java program in (Listing 1). This task was performed before
they had any exposure to Java. P2 explained each line of code, as
follows:
•
line 1: "Hmm, it looks completely new. Hmm, I’m not entirely
sure what line 1 is trying to specify."
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
309
•
line 2: "Looks like its assigning value to variable and saying
that the variable is an integer [says integer with lower voice],
so its saying length is an integer with a value 3."
•
line 4: "It looks a bit like a Python function, there are brackets
that seems to be a parameter. The name of the function is
main
.
looks like its specifying a string argument [unsure in their
voice]. I have never seen public, static and main."
•
line 5: Line 5 [pauses], I’m not entirely sure, looks like its
calling a
rectangle
because of the brackets which Python
uses when calling a function, but I’m not sure from where.
•
line 6: Looks like its related to line 5. Like here,
insert(12,4)
,
maybe that’s how you put arguments in a function.
•
line 8: It looks like another function, ehh , called
insert
with
what seems to be integer parameters
l
and
w
, looks like a tiny
bit of Python. It says it has to return an integer [unsure in their
voice]. I have never used public before.
•
line 9: The result is going to be an integer and multiplies
l*w
,
similar to Python.
•
line 10-13: It is an if-else conditional comparing if
l
is greater
than w. Line 11 prints because it has the word print and prints
the answer is
l*w
, if its false it goes to line 13 and prints no
result.
•line 14: It returns whatever result is.
Student P2 was then asked to predict what the output of the program
in (Listing 1) will be when executed:
•
"It will print the answer is 48. There is a lot I don’t understand,
but I notice in line 6 there is an insert function being called
which is in line 8, with
l
and
w
being the parameters. In line
9,
l*w
is 48,
l
is greater than
w
, which is true and it will
print out "The answer is 48" in line 11. I did not use
length
and
width
variables because I did not see where they were
used."
3.2.2 Analysis.
With no prior exposure to Java, P2 was seen to explicitly match Java
syntax to known Python syntax hence showing they also perceived
the constructs as Carryover [
1
], for example in their explanations
of how they executed the program, the student shows they made
the syntax mappings (lexical associations) of Python and Java and
subsequent semantic transfer in line with Jiang
'
s semantic transfer
theory in stages 1 and 2. This means that P2 interpreted the Java
program based on their Python semantic knowledge. By this means,
lines 2-4 and 8-14 were well enough matched to Python concepts
of variables, function declarations and calls, if statements, return
statements and output statements, this was also the case for the
other students. All the students but one(P1) gave the correct output
for the code. As the student explained the program, (P1) said: "I
think it will print "no result", I mean I do not understand lines 4-7, if
you take
l
to be
length
and
w
to be
width
, 3 is not bigger that 4,
although I am not sure if it is being passed anywhere."
What we see in (P1)
'
s think aloud is that they ignored the lines
of code that they could not match to Python such as the Java main
method and objects and decided to explain the lines of code they
could match resulting in a wrong answer. This shows that percep-
tions of similarity between languages can vary amongst students
[
15
]. If there was no obvious syntax match to Python, as in lines 1
and 5, then the syntax or construct was glossed over and perceived
as Novel[
1
]. However, these lines were peripheral to the overall
operation of the program, hence the mostly correct answers on the
output. The more experienced student managed to understand all
lines and kept making analogies to either Python or C++:"line 5
we are constructing an object of type rectangle and assigning it to
variable r1" (P5).
3.3 Session 2
This second study, conducted two weeks into the course, explored
Java concepts already covered by that time. Participants were given
ve multiple-choice questions, each giving a short Python code
snippet and a number of Java code snippets; they had to pick the
one matching the Python code.
3.3.1 Results.
Student P3 made correct mappings of the program execution out-
puts between the Python program and the corresponding Java pro-
gram for concepts such as conditional statement and swapping vari-
ables, replicating the ndings from the rst session. However, they
were confused by variable reassignment in Figure 1, they mapped it
to Java version (a).
•
"In Python, because you do not have to specify the type, printing
out
a
would print ’Hello’. If you need to assign the value
a
to a
String you need to write
String a="Hello"
. This is why
I said answer (a) is correct. I am not sure what will actually be
printed out when the Java code runs, probably "Hello" as well
like in Python."
Student P1 also did the same wrong match while the rest of the
students mapped it correctly to (option (c)).
3.3.2 Analysis.
P3 assumed that because syntax dierences are so small, the se-
mantics are similar. These results supports the Mindshift Learning
Theory [
1
] of a Changed Concept. Note that P3 has the correct
Python execution model for the variable reassignment , but car-
ries the correct Python variable reassignment model across to the
Java code showing that they base their interpretation on syntax
similarities between Python and Java and the only dierence they
see is that Java species type and Python does not therefore both
programs have the same meaning, this is evidence of semantic
transfer. P3 has not assimilated the idea that types go deeper than
syntax alone. Variable
a
in Java is statically typed. That means this
variable is initially declared to have a specic data type, and any
value assigned to it during its lifetime must always have that type.
Since Python is dynamically typed, variable
a
may be assigned a
value of one type and then later re-assigned a value of a dierent
type.
3.4 Session 4
When reviewing the students’ condence levels (level 0 being the
least condent and level 5 being the most condent) with dier-
ent concepts in week 6, most were very uncertain about objects
as seen in Figure 2. In this study, therefore, we wanted to explore
what students understood about objects. As well as students’ un-
derstanding about objects, we also wanted to explore how we can
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
310
Figure 1: Variable assignment question on Java and Python
Figure 2: Week 6 condence levels
help them comprehend objects better by showing them that they
map to the concept of user-dened data types although they are
more abstract [
2
] [
33
]. Having observed in the previous sessions
that students transfer by syntax matching, we gave them a Java
objects program which was mapped to Python dictionaries and
associated functions. Participants were asked to identify similari-
ties and dierences between the two programs and write down the
program outputs.
3.4.1 Results.
The session started with asking student P1 to talk through their
understanding of objects so far since it was week 6 having started
Java lessons.
•
"Well, I thought an object is actually an interface or class
..what!...what! [they exclaim]. So I think its the most confusing
part. I’m still not a 100 percent sure what they are. I mean our
lecturer mentions objects sometimes but I still don’t get it, I
might have to go over our notes again."
The student misconceptions about objects are well documented
[
4
,
27
]. Understanding the dierence between class and object seems
to be a challenge for novices as shown in P1’s explanation.
P1 was presented with the Python and Java program in Listing 2
and Listing 3 respectively. They were asked to talk through the
programs and discuss what they see as similar or dierent between
them.
•
"An object is created in Java and then you create elds for
the object in line 16 and 17 and those elds are similar to the
entries in the dictionary for the Python in line 8 and 9. I see
methods where elds are accessed in both programs for each
person that is created ..mhh.. which has the name and the age,
for example in the Java,
getName
access the name eld and
in Python it gets name key for the dictionary."
P1 recognised some similarities between Python dictionaries/-
functions and Java objects as both having attributes and subpro-
grams
getName
that manipulate them. They associated dictionary
variables
me
and
you
with object variables
n1
and
n2
. Python
dictionaries and Java objects share similarities in that they are both
data structures, the dierence is that objects have a more abstract or
hidden representation[
11
] while a Python dictionary has a concrete
representation.
P1 was asked to discuss their understanding of objects again
after making the comparisons.
•
"It makes sense now. When I create an object, it doesn’t show me
the data structure or how it will be saved, having a dictionary
helped me visualise it because dictionaries are actually what I
understand because in a dictionary you will know there will
be a eld called Joseph and a eld called 51."
Like P1, other students still had confusions about objects except
for (P5) in week 6, for example "With objects I still do not get how they
work, or how you set them up with packages and methods." (P4) and
"Objects are a dicult topic to grasp, sometimes I try to make sense
of them using my general English understanding of an object." (P3).
While the experienced programmer seemed to not have a problem:
I have no confusions with objects because i did them in c++.(P5).
These students seemed to change their views after the Python
dictionary and Java object comparisons, for example "When you say
the word object it seems like its this abstract thing. I think now I see an
object as an advanced way to store data and give you options to pass
it around like lists and dictionaries with techniques to manipulate the
data. its a lot simpler to understand objects than what you kinda like
think at rst." (P4).
3.4.2 Analysis.
After the intervention, we believe students started noticing the
structural similarities in syntax in the way the programs were de-
signed in Listing 2 and Listing 3 even though the syntax diered sig-
nicantly. Hence, they were able to transfer their existing semantics
of data structures and functions across to Java supporting Semantic
transfer theory [
7
,
8
]. This session suggests that when similar con-
cepts do not look the same, it is harder for participants to carryout
a conceptual and semantic transfer. We use Mindshift Learning
theory to categorise the object concept as initially perceived as a
novel concept by participants, however they later realised it is a
carryover concept expressed in a totally new syntax.
1def p(n,a):
2return {'name':n, 'age':a}
3def getName(obj):
4return obj['name']
5def incAge(obj):
6a = obj["age"]+1
7return a
8me=p("Joseph", 51)
9you=p("Vic", 35)
10 print("your name is:", getName(me),", your age is:",
11 incAge(me))
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
311
12 print("your name is:", getName(you),", your age is:",
13 incAge(you))
Listing 2: Python Program Session 4
1public class person{
2public String name;
3public int age;
4public person (String n, int a){
5this.name=n;
6this.age=a;
7}
8public String getName(){
9return name;
10 }
11 public int incAge(){
12 int a=age+1;
13 return a;
14 }
15 public static void main(String []args){
16 person n1=new person("Joseph",51);
17 person n2=new person("Vic",35);
18 System.out.println("Your name is: "+n1.getName()+
19 " Age:" +n1.incAge());
20 System.out.println("Your name is: "+n2.getName()+
21 " Age:" +n2.incAge());
22 }
23 }
Listing 3: Java Program Session 4
4 DISCUSSION
In answering the research question, we noted that conceptual trans-
fer did take place at the semantic level, in line with Jiang
'
s model of
semantic transfer for natural languages, based on the matching of
syntax. The principle factor inuencing the success of the transfer
was whether the matched syntax had the same conceptual meaning
or not in the new language as in the old language, following on
from Anderson et al.
'
s Mindshift notions of Carryover, Changed
and Novel concepts. The ndings are explored in more details as
follows.
Participants had little diculty with Carryover concepts such as
variables, conditional-statements, methods and parameter passing,
executing programs in both Python and Java successfully. Once the
syntax was matched across the languages, the semantic transfer
was appropriate for these concepts, and the learning process was
positive, as shown in both session 1 and session 2.
During the initial learning stages, participants relied mostly on
their syntactic matching between the languages and subsequent
semantic transfer on both Carryover and Changed concepts. This
meant, however, that their mappings were wrong for Changed
concepts. For example, some participants had diculty with the
variable reassignment, as seen in session 2. They showed they were
transferring their Python semantic knowledge in order to (incor-
rectly) understand the Java variable reassignment, e.g the P1 and P3
examples in session 2. These results show that when syntax match-
ing and corresponding semantic transfer take place for a Changed
concept, they impact negatively on the learning process of the new
language.
Initially, participants could not map the object concept to their
existing knowledge structures, because the syntax of this concept
was at too high a level, not resembling any known syntax in proce-
dural Python. The lack of syntax matching resulted in no semantic
transfer. As the learning progressed, participants perceived the
concept as Novel, and objects remained at least partially Novel to
them throughout the course, e.g. consider session 4 at week 6 of
their learning. This made their learning of these concepts less eec-
tive. Participants were assisted through interventions to help them
recognise that objects are not as Novel as they thought, and that
they correspond to a concrete data type, implemented in Python
using dictionaries and functions, as shown in session 4.
The limitations of our study are that it was exploratory and in-
volved observing students
'
conceptual transfer at various points in
time. This meant that each study was built from analysis results of
the previous study, hence that limited us on the number of program-
ming concepts we could investigate in the given time period. Due
to the nature of this study, we also used a small sample size which
may not adequately represent the target population or generalise to
a wider population. However the study will serve as a foundation
for us to do further research with a larger statistically signicant
sample size.
5 CONCLUSIONS
Our study explored relative novice programmers learning a new
PL, to nd out what type of transfer occurs and why. Prior work
has explored how experienced programmers transition, focusing on
problem solving approaches used and discovered that plan transfer
can occur during transition. However prior work did not focus on
the cognitive processes of a relative novice programmer’s transition,
which has been our focus. We used a code comprehension approach
to examine transition through the context of relative novices transi-
tioning from procedural Python to Java. Our ndings indicate they
make use of semantic transfer on initial stages of learning a new lan-
guage, which is inuenced by their perception of whether concepts
are Carryover, Changed or Novel between the languages. When
their perceptions do not match the true nature of the conceptual
transfer, learning suers. Our ndings indicate that it was easier for
learners to transition correctly on Carryover concepts than Novel
or Changed concepts. Our long term goal in this research is to build
a model of PL transfer, hence this study will provide initial insights
into understanding this transfer phenomenon.
5.1 Implications to teaching
We suggest that second and subsequent PL teachers should be aware
of what languages the students have learned prior to the course.
As each new construct is introduced in the new language, explicit
reference can be made to the ideas of perceived Carryover, Novel
and Changed, relating back to the earlier languages. Either explicitly
or implicitly, the idea that the same syntax can mean dierent things
can be reinforced, and can be taken as an opportunity to teach
deeper programming concepts such as dynamic typing versus static
typing. We also muse on academics saying of their introductory
class "I wish they hadn’t learned programming before, I have to unpick
all the incorrect understandings." Could such comments arise from
the instructor’s lack of appreciation that those understandings were
correct in the original context, and that this is just the nature of
transfer?
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
312
REFERENCES
[1]
Deborah J Armstrong and Bill C Hardgrave. 2007. Understanding mindshift
learning: the transition to object-oriented development. MIS Quarterly (2007),
453–474.
[2]
William R Cook. 2009. On understanding data abstraction, revisited. In ACM
SIGPLAN Notices, Vol. 44. ACM, 557–572.
[3]
Wanda Dann, Dennis Cosgrove, Don Slater, Dave Culyba, and Steve Cooper. 2012.
Mediated transfer: Alice 3 to Java.. In SIGCSE, Vol. 12. Citeseer, 141–146.
[4]
Anna Eckerdal and Michael Thuné. 2005. Novice Java programmers’ conceptions
of object and class, and variation theory. In ACM SIGCSE Bulletin, Vol. 37. ACM,
89–93.
[5]
Richard Hayes, Brittany Kyer, and Emily Weber. 2015. The case study cookbook.
available at: le:///E:/Scoping/Case% 20Studies/CaseTypePDF. pdf (accessed August
17, 2018).[Google Scholar] (2015).
[6]
Michael Homer and James Noble. 2014. Combining tiled and textual views of
code. In 2014 Second IEEE Working Conference on Software Visualization. IEEE,
1–10.
[7]
Nan Jiang. 2000. Lexical representation and development in a second language.
Applied linguistics 21, 1 (2000), 47–77.
[8]
Nan Jiang. 2004. Semantic transfer and its implications for vocabulary teaching
in a second language. The modern language journal 88, 3 (2004), 416–432.
[9]
Michael Kölling, Neil CC Brown, and Amjad Altadmri. 2015. Frame-based editing:
Easing the transition from blocks to text-based programming. In Proceedings of
the Workshop in Primary and Secondary Computing Education. ACM, 29–38.
[10]
Colleen M Lewis. 2012. The importance of students’ attention to program state: a
case study of debugging behavior. In Proceedings of the ninth annual international
conference on International computing education research. ACM, 127–134.
[11]
Barbara Liskov, Alan Snyder, Russell Atkinson, and Craig Schaert. 1977. Ab-
straction mechanisms in CLU. Commun. ACM 20, 8 (1977), 564–576.
[12] H James Nelson, Gretchen Irwin, and David E Monarchi. 1997. Journeys up the
mountain: Dierent paths to learning object-oriented programming. Accounting,
Management and Information Technologies 7, 2 (1997), 53–85.
[13]
Norman Peitek, Janet Siegmund, Sven Apel, Christian Kästner, Chris Parnin, Anja
Bethmann, Thomas Leich, Gunter Saake, and André Brechmann. 2018. A Look
into Programmers’ Heads. IEEE Transactions on Software Engineering (2018).
[14]
Kris Powers, Stacey Ecott, and Leanne M Hirsheld. 2007. Through the looking
glass: teaching CS0 with Alice. In SIGCSE, Vol. 7. Citeseer, 213–217.
[15]
Håkan Ringbom. 2007. Cross-linguistic similarity in foreign language learning.
Vol. 21. Multilingual Matters.
[16]
Jean Scholtz and Susan Wiedenbeck. 1990. Learning second and subsequent
programming languages: A problem of transfer. International Journal of Human-
Computer Interaction 2, 1 (1990), 51–72.
[17]
Jean Scholtz and Susan Wiedenbeck. 1991. Learning a new programming lan-
guage: a model of the planning process. In Proceedings of the Twenty-Fourth
Annual Hawaii International Conference on System Sciences, Vol. 2. IEEE, 3–12.
[18]
Jean Scholtz and Susan Wiedenbeck. 1992. An analysis of novice programmers
learning a second language.. In PPIG (1). 9.
[19]
Jean Scholtz and Susan Wiedenbeck. 1993. Using unfamiliar programming
languages: the eects on expertise. Interacting with Computers 5, 1 (1993), 13–30.
[20]
Carsten Schulte. 2008. Block Model: an educational model of program compre-
hension as a tool for a scholarly approach to teaching. In Proceedings of the Fourth
international Workshop on Computing Education Research. ACM, 149–160.
[21]
Carsten Schulte, Tony Clear, Ahmad Taherkhani, Teresa Busjahn, and James H
Paterson. 2010. An introduction to program comprehension for computer science
educators. In Proceedings of the 2010 ITiCSE working group reports. ACM, 65–86.
[22]
Kristin A Searle and Yasmin B Kafai. 2015. Boys’ Needlework: Understanding Gen-
dered and Indigenous Perspectives on Computing and Crafting with Electronic
Textiles.. In ICER. 31–39.
[23]
Ben Shneiderman and Richard Mayer. 1979. Syntactic/semantic interactions in
programmer behavior: A model and experimental results. International Journal
of Computer & Information Sciences 8, 3 (1979), 219–238.
[24]
Nischal Shrestha. 2018. Towards Supporting Knowledge Transfer of Programming
Languages. In 2018 IEEE Symposium on Visual Languages and Human-Centric
Computing (VL/HCC). IEEE, 275–276.
[25]
Robert S Siegler and Kevin Crowley. 1991. The microgenetic method: A direct
means for studying cognitive development. American psychologist 46, 6 (1991),
606.
[26]
Janet Siegmund, Christian Kästner, Sven Apel, Chris Parnin, Anja Bethmann,
Thomas Leich, Gunter Saake, and André Brechmann. 2014. Understanding
understanding source code with functional magnetic resonance imaging. In
Proceedings of the 36th International Conference on Software Engineering. ACM,
378–389.
[27]
Juha Sorva. 2018. Misconceptions and the beginner programmer. Computer
Science Education: Perspectives on Teaching and Learning in School (2018), 171.
[28]
Andreas Stek and Susanna Siebert. 2013. An empirical investigation into pro-
gramming language syntax. ACM Transactions on Computing Education (TOCE)
13, 4 (2013), 19.
[29]
Donna Teague and Raymond Lister. 2014. Longitudinal think aloud study of
a novice programmer. In Proceedings of the Sixteenth Australasian Computing
Education Conference-Volume 148. Australian Computer Society, Inc., 41–50.
[30]
Winston M Tellis. 1997. Introduction to case study. The qualitative report 3, 2
(1997), 1–14.
[31]
Anneliese Von Mayrhauser and A Marie Vans. 1995. Program comprehension
during software maintenance and evolution. Computer 28, 8 (1995), 44–55.
[32]
Karen P Walker and Stephen R Schach. 1996. Obstacles to learning a second
programming language: An empirical study. Computer Science Education 7, 1
(1996), 1–20.
[33]
David A Watt. 2004. Programming language design concepts. John Wiley & Sons.
[34]
David Weintrop, Connor Bain, Uri Wilensky, and UChicago STEM Education.
2017. Blocking progress? Transitioning from block-based to text-based program-
ming.
[35]
David Weintrop and Uri Wilensky. 2015. Using Commutative Assessments to
Compare Conceptual Understanding in Blocks-based and Text-based Programs..
In ICER, Vol. 15. 101–110.
[36]
David Weintropand Uri Wilensky. 2018. How block-based, text-based, and hybrid
block/text modalities shape novice programming practices. International Journal
of Child-Computer Interaction 17 (2018), 83–92.
[37]
Quanfeng Wu and John R Anderson. 1990. Problem-solving transfer among
programming languages. Technical Report. CARNEGIE-MELLON UNIV PITTS-
BURGH PA ARTIFICIAL INTELLIGENCE AND PSYCHOLOGY .. ..
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
313
