Conference PaperPDF Available

Semantic Transfer in Programming Languages: Exploratory Study of Relative Novices


Abstract and Figures

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 difficulties that students face when learning new languages. In addition, work that directly relates to PL transfer mainly concerns experienced programmers problem solving in a new language, evidencing plan transfer. We could not find research attempting to devise a model of PL transfer based on code comprehension. We explore this phenomenon in the context of five 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 findings indicate that during the initial learning stages, learners relied mostly on their syntactic matching between Python and Java and subsequent semantic transfer which affected 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 effective learning process, and we provide pointers in this direction.
Content may be subject to copyright.
Semantic Transfer in Programming Languages: Exploratory
Study of Relative Novices
Ethel Tshukudu
University of Glasgow
Glasgow, UK
Quintin Cutts
University of Glasgow
Glasgow, UK
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 aected 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 eective learning process, and we provide
pointers in this direction.
Social and professional topics Computer science educa-
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.
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 prot 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 specic permission and/or a
fee. Request permissions from
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
©2020 Association for Computing Machinery.
ACM ISBN 978-1-4503-6874-2/20/06. . . $15.00
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.
]. 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-
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[
] and natural language[
] 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
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 [
method calls, parameter passing, return values, variable assign-
ments, data types, expressions. Other studies that identied similar
challenges are [
]. 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 dierent tex-
tual languages. For example, Walker et al. [
] 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 dierent 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 [
]. 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 conrm that novices face diculty 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 Experienced programmers transfer via
problem solving
Anderson et al. [
] 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 [
] 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 [
]. Scholtz et al. [
] 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
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 [
]. 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
], 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. [
]. 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
dierent meaning in the new context.
A Novel concept is a concept not already known to the
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 [
]. In addition to the MLT we will also
draw from Jiang
s second language acquisition model [
] based
on a notion of semantic transfer and consisting of three stages:
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
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.
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.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 [
]. 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 [
]. 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[
], the results will be analysed through
the lens of second natural language acquisition model based on
semantic transfer [
] 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 condence 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 [
] which is used to assess
1public class Rectangle {
2int length=3;
3int width=4;
4public static void main(String args[]) {
5Rectangle r1=new Rectangle();
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 [
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 identied 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
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
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
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
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
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,
maybe that’s how you put arguments in a function.
line 8: It looks like another function, ehh , called
what seems to be integer parameters
, 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
similar to Python.
line 10-13: It is an if-else conditional comparing if
is greater
than w. Line 11 prints because it has the word print and prints
the answer is
, if its false it goes to line 13 and prints no
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
being the parameters. In line
is 48,
is greater than
, which is true and it will
print out "The answer is 48" in line 11. I did not use
variables because I did not see where they were
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 [
], 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
to be
to be
, 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
]. 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[
]. 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
would print ’Hello’. If you need to assign the value
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 dierences are so small, the se-
mantics are similar. These results supports the Mindshift Learning
Theory [
] 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 dierence they
see is that Java species 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
in Java is statically typed. That means this
variable is initially declared to have a specic data type, and any
value assigned to it during its lifetime must always have that type.
Since Python is dynamically typed, variable
may be assigned a
value of one type and then later re-assigned a value of a dierent
3.4 Session 4
When reviewing the students’ condence levels (level 0 being the
least condent and level 5 being the most condent) with dier-
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
Figure 1: Variable assignment question on Java and Python
Figure 2: Week 6 condence levels
help them comprehend objects better by showing them that they
map to the concept of user-dened data types although they are
more abstract [
] [
]. 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 dierences 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
]. Understanding the dierence 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 dierent between
"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,
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-
that manipulate them. They associated dictionary
with object variables
. Python
dictionaries and Java objects share similarities in that they are both
data structures, the dierence is that objects have a more abstract or
hidden representation[
] while a Python dictionary has a concrete
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 dicult 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 diered sig-
nicantly. Hence, they were able to transfer their existing semantics
of data structures and functions across to Java supporting Semantic
transfer theory [
]. 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
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){;
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
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 inuencing 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
Participants had little diculty 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 diculty 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
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 eec-
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 signicant
sample size.
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 inuenced 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 suers. 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 dierent 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
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
Deborah J Armstrong and Bill C Hardgrave. 2007. Understanding mindshift
learning: the transition to object-oriented development. MIS Quarterly (2007),
William R Cook. 2009. On understanding data abstraction, revisited. In ACM
SIGPLAN Notices, Vol. 44. ACM, 557–572.
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.
Anna Eckerdal and Michael Thuné. 2005. Novice Java programmers’ conceptions
of object and class, and variation theory. In ACM SIGCSE Bulletin, Vol. 37. ACM,
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).
Michael Homer and James Noble. 2014. Combining tiled and textual views of
code. In 2014 Second IEEE Working Conference on Software Visualization. IEEE,
Nan Jiang. 2000. Lexical representation and development in a second language.
Applied linguistics 21, 1 (2000), 47–77.
Nan Jiang. 2004. Semantic transfer and its implications for vocabulary teaching
in a second language. The modern language journal 88, 3 (2004), 416–432.
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.
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.
Barbara Liskov, Alan Snyder, Russell Atkinson, and Craig Schaert. 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: Dierent paths to learning object-oriented programming. Accounting,
Management and Information Technologies 7, 2 (1997), 53–85.
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).
Kris Powers, Stacey Ecott, and Leanne M Hirsheld. 2007. Through the looking
glass: teaching CS0 with Alice. In SIGCSE, Vol. 7. Citeseer, 213–217.
Håkan Ringbom. 2007. Cross-linguistic similarity in foreign language learning.
Vol. 21. Multilingual Matters.
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.
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.
Jean Scholtz and Susan Wiedenbeck. 1992. An analysis of novice programmers
learning a second language.. In PPIG (1). 9.
Jean Scholtz and Susan Wiedenbeck. 1993. Using unfamiliar programming
languages: the eects on expertise. Interacting with Computers 5, 1 (1993), 13–30.
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.
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.
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.
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.
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.
Robert S Siegler and Kevin Crowley. 1991. The microgenetic method: A direct
means for studying cognitive development. American psychologist 46, 6 (1991),
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,
Juha Sorva. 2018. Misconceptions and the beginner programmer. Computer
Science Education: Perspectives on Teaching and Learning in School (2018), 171.
Andreas Stek and Susanna Siebert. 2013. An empirical investigation into pro-
gramming language syntax. ACM Transactions on Computing Education (TOCE)
13, 4 (2013), 19.
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.
Winston M Tellis. 1997. Introduction to case study. The qualitative report 3, 2
(1997), 1–14.
Anneliese Von Mayrhauser and A Marie Vans. 1995. Program comprehension
during software maintenance and evolution. Computer 28, 8 (1995), 44–55.
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.
David A Watt. 2004. Programming language design concepts. John Wiley & Sons.
David Weintrop, Connor Bain, Uri Wilensky, and UChicago STEM Education.
2017. Blocking progress? Transitioning from block-based to text-based program-
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.
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.
Quanfeng Wu and John R Anderson. 1990. Problem-solving transfer among
programming languages. Technical Report. CARNEGIE-MELLON UNIV PITTS-
Session: Curriculum
ITiCSE ’20, June 15–19, 2020, Trondheim, Norway
... Research on programming language transfer has reported that conceptual transfer from the first to subsequent programming language often does not occur as expected in the classroom. Students often show little ability to apply knowledge of what they learnt in previous languages taught in the classroom to new languages, and this is especially the case for abstract concepts [2,31,41,42]. Furthermore, research reports that negative transfer from the previous language may impede learning of a new language [33,45,47]. ...
... Furthermore, research reports that negative transfer from the previous language may impede learning of a new language [33,45,47]. Despite the reported failures of transfer, some successes have been reported too [8,35,41]. These usually occur when previous languages share syntax and semantic similarities with new languages. ...
... Weintrop and Wilensky [47] also reported that students struggled with Java errors such as undefined variables and incompatible types when transitioning from block-based languages to Java. Other studies have reported transition problems that students often struggle with when transitioning between different textual languages [31,41,45,48]. For example, in their experiment of students transitioning from Pascal to a new Ada language, Walker and Schach [45] reported that some students preferred to write Ada programs using a familiar while loop construct from their prior language instead of switching to the Ada loop-exit-end structure. ...
... This line of research has largely not been model-driven, hence not describing the cognitive processes and mechanisms involved in learning new PLs. An effort to overcome these problems can be seen in the recent studies by Tshukudu and Cutts, that evidenced semantic transfer from prior PLs in learning new PLs [25,26]. They proposed a model of PL transfer based on the notion of semantic transfer [27]. ...
... inheritance and concurrency) and FCC (e.g type coercion). According to the MPLT, the ATCC and FCC categories are usually the most problematic during transfer [25][26][27]. ...
... These low scores are as a result of negative semantic transfer from Python. These findings corroborates with findings from prior work [26,27] on negative impacts of semantic transfer. ...
Conference Paper
Full-text available
Students are expected to move from one programming language (PL) to another in their computer science education. Recent work has proposed a model of PL transfer to explain how students trans- fer conceptual knowledge between languages. This model suggests that during the transition, learners automatically effect a transfer of semantics between languages based on syntax similarities. The semantic transfer can be positive for learning when the syntax and semantics of the new PL are similar to the prior PL (True Carryover Constructs) and becomes negative when the syntax of the prior PL is similar to the new PL but the semantics are different (False Carryover Constructs). To avoid negative semantic transfer during learning, this study aims to investigate the effectiveness of explicit instruction in teaching a second PL by conducting two empirical studies. Study 1 was a within-subject study that investigated under- graduate students transitioning from procedural Python to object- oriented Java. Study 2 was a between-subject study that investigated undergraduate students transitioning from object-oriented Python to object-oriented Java at a different university. The results of both studies show that students benefited significantly more on interven- tions on the False Carryover Constructs categories than the True Carryover Constructs. These findings can help teachers interpret and improve their own classroom practices when teaching second PLs.
... This study addresses the need for PL transfer research in CS education by proposing a model of PL transfer that was designed on the basis of our preliminary transfer study [46] and borrows from programming language and natural language theories, as explained in the next section. ...
... objects and dictionaries as data structures. Details of this study can be seen in [46]. ...
... The learning process is derived from natural language theories explained in Section 2. Jiang's model of semantic transfer [19,21] and Ringbom's cross-linguistic similarity relations [33] are merged and refined to suit the programming language transfer context. At this step of model building, we used an inductive approach [45] to refine theory based on the qualitative data from the preliminary study [46]. At the initial stages of learning PL2, programmers will engage in learning three categories of concepts, TCC, FCC and ATCC. ...
Conference Paper
Full-text available
Prior research has shown that students face transition challengesbetween programming languages (PL) over the course of theireducation. We could not find research attempting to devise a modelthat describes the transition process and how students’ learning ofprogramming concepts is affected during the shift. In this paper, wepropose a model to describe PL transfer for relative novices. In themodel, during initial stages of learning a new language, studentswill engage in learning three categories of concepts, True CarryoverConcepts, False Carryover Concepts, or Abstract True CarryoverConcepts; during the transition, learners automatically effect atransfer of semantics between languages based on syntax matching.In order to find support for the model, we conducted two empiricalstudies. Study 1 investigated near-novice undergraduate studentstransitioning from procedural Python to object-oriented Java whileStudy 2 investigated near-novice postgraduate students doing atransfer from object-oriented Java to procedural Python. Results forboth studies indicate that students had little or no difficulty withtransitioning on TCC due to positive semantic transfer based onsyntax similarities while they had the most difficulty transitioningon FCC due to negative semantic transfer. Students had little or nosemantic transfer on ATCC due to differences in syntax betweenthe languages. We suggest ways in which the model can informpedagogy on how to ease the transition process.
... Other potential reasons could also be because the lecturer expressed a lack of confidence in making the bridging intervention due to limited Python knowledge. The ATCC interventions need careful step-by-step scaffolding activities that also show structural similarities in connecting abstract concepts, such as in [42]. ...
The overall aim of this paper is to stimulate discussion about the activities within CER, and to develop a more thoughtful and explicit perspective on the different types of research activity within CER, and their relationships with each other. While theories may be the most valuable outputs of research to those wishing to apply them, for researchers themselves there are other kinds of contribution important to progress in the field. This is what relates it to the immediate subject of this special journal issue on theory in CER. We adopt as our criterion for value “contribution to knowledge”. This paper’s main contributions are: • A set of 12 categories of contribution which together indicate the extent of this terrain of contributions to research. • Leading into that is a collection of ideas and misconceptions which are drawn on in defining and motivating “ground rules”, which are hints and guidance on the need for various often neglected categories. These are also helpful in justifying some additional categories which make the set as a whole more useful in combination. These are followed by some suggested uses for the categories, and a discussion assessing how the success of the paper might be judged.
Hedy is a programming language that implements the gradual programming approach in which the goal is to lower the syntax barrier by starting with a very simple language, and gradually adding both concepts and refining syntax. This paper describes the design and implementation of Hedy, as well as a first user study involving 39 children between the ages of 11 and age 14 who followed online lessons for six weeks. Based on lesson observations and a written survey filled out by the participants, we aim to understand the impact of using a gradual language. Our findings show that children appreciate the gradual nature of Hedy, find Hedy easy to learn and especially appreciate the power to control the difficulty of Hedy themselves. They also like and frequently use built-in educational features like example code snippets. Challenges of a gradual approach are the fact that commands sometimes change or overlap, and remembering commands and specific syntax remain a challenge. According to the participants, improvements could be made by making Hedy less sensitive to syntax errors, by improving error messages and by localizing keywords to the native language of children.
The 1980s and 1990s saw a robust connection between computer science education and cognitive psychology as researchers worked to understand how students learn to program. More recently, academic disciplines such as science and engineering have begun drawing on cognitive psychology research and theories of learning to create instructional materials and teacher professional development materials based on theories of learning, to some success. In this paper, we follow a similar approach by highlighting common areas of interest between computer science education and cognitive psychology–specifically theories of analogical transfer–and discuss how cross-pollination of theoretical constructs between disciplines can support research on the teaching and learning of multiple programming languages. We will also discuss areas where computing education research can adapt the existing theories from cognitive psychology to develop domain-specific theories of knowledge transfer in computing and feed back into cognitive psychology research to inform larger debates about the nature of cognition and learning.
Conference Paper
Full-text available
We draw attention to the intersection of race/ethnicity and gender in computing education by examining the experiences of ten American Indian boys (12-14 years old) who participated in introductory computing activities with electronic textiles. To date, the use of electronic textiles (e-textiles) materials in introductory computing activities have been shown to be particularly appealing to girls and women because they combine craft, circuitry, and computing. We hypothesized that e-textiles would be appealing to American Indian boys because of a strong community-based craft tradition linked to heritage cultural practices. In order to understand boys' perspectives on learning computing through making culturally-relevant e-textiles artifacts, we analyzed boys' completed artifacts as documented in photographs and code screenshots, their design practices as documented in daily field notes and video logs of classroom sessions, and their reflections from interviews guided by the following research questions: (1) How did American Indian boys initially engage with e-textiles materials? (2) How did boys' computational perspectives develop through the process of making and programming their own e-textiles artifacts? Our findings highlight the importance of connecting to larger community value systems as a context for doing computing, the importance of allowing space for youth to make decisions within the constraints of the design task, and the value of tangible e-textiles artifacts in providing linkages between home and school spaces. We connect our work to other efforts to engage racial and ethnic minority students in computing and discuss the implications of our work for computer science educators designing computing curricula for increasingly diverse groups of students, especially as pertains to the emerging field of culturally responsive computing.
Conference Paper
Full-text available
Block-based programming systems, such as Scratch or Alice, are the most popular environments for introducing young children to programming. However, mastery of text-based programming continues to be the educational goal for students who continue to program into their teenage years and beyond. Transitioning across the significant gap between the two editing styles presents a difficult challenge in school-level teaching of programming. We propose a new style of program manipulation to bridge the gap: frame-based editing. Frame-based editing has the resistance to errors and approachability of block-based programming while retaining the flexibility and more conventional programming semantics of text-based programming languages. In this paper, we analyse the issues involved in the transition from blocks to text and argue that they can be overcome by using frame-based editing as an intermediate step. A design and implementation of a frame-based editor is provided.
Full-text available
Jigsaw puzzle programming environments manipulate programs primarily by drag-and-drop. Generally these environments are based on their own special-purpose languages, meaning students must move on to another language as their programs grow. Tiled Grace is a tile-based editor for Grace, an educational programming language with a conventional textual syntax. Using Tiled Grace, programmers can move seamlessly between visualising their programs as tiles or source code, editing their programs via tiles or text, and continue on to traditional textual environments, all within the same programming language. We conducted a user experiment with Tiled Grace, and present the results of that experiment showing that users find dual views helpful.
Full-text available
A psycholinguistic model of vocabulary acquisition in a second language (L2) in instructional settings is outlined in this paper. Considered in light of how the lexical entries in the L2 lexicon evolve, L2 vocabulary acquisition is seen as consisting of three stages: the formal stage when a lexical entry with formal speci®cations is established, the ®rst language (L1) lemma mediation stage when the lemma information of the L1 counterpart is copied into the L2 lexical entry and mediates L2 word use, and the L2 integration stage when semantic, syntactic, morphological speci®cations are integrated into the lexical entry. It is argued that due to the practical constraints imposed on L2 learning, a majority of L2 words fossilize at the second stage. Thus, lexical representation in L2 in general has three unique features: (a) a lexical entry consists of L2 lexeme and L1 lemma; (b) little morphological speci®cations are integrated within the entry; (c) the links between L2 words and concepts are weak. The processing consequences of these features, relevant research evidence in support of this model, and its implications for L2 vocabulary acquisition research are discussed.
This book explores the importance of cross-linguistic similarity in foreign language learning. While linguists have primarily focussed upon differences between languages, learners strive to make use of any similarities to prior linguistic knowledge they can perceive. The role of positive transfer is emphasized as well as the essential differences between comprehension and production. In comprehension of related languages, cross-linguistic similarities are easily perceived while in comprehension of distant languages they are merely assumed. Production may be based on previous perception of similarities, but frequently similarities are here merely assumed. Initially, effective learning is based on quick establishment of cross-linguistic one-to-one relations between individual items. As learning progresses, the learner learns to modify such oversimplified relations. The book describes the ways in which transfer affects different areas of language, taking account of the differences between learning a language perceived to be similar and a language where few or no cross-linguistic similarities can be established.
Please see my Web site for the full text: Program comprehension is an important, but hard to measure cognitive process. This makes it difficult to provide suitable programming languages, tools, or coding conventions to support developers in their everyday work. Here, we explore whether functional magnetic resonance imaging (fMRI) is feasible for soundly measuring program comprehension. To this end, we observed 17 participants inside an fMRI scanner while they were comprehending source code. The results show a clear, distinct activation of five brain regions, which are related to working memory, attention, and language processing, which all fit well to our understanding of program comprehension. Furthermore, we found reduced activity in the default mode network, indicating the cognitive effort necessary for program comprehension. We also observed that familiarity with Java as underlying programming language reduced cognitive effort during program comprehension. To gain confidence in the results and the method, we replicated the study with 11 new participants and largely confirmed our findings. Our results encourage us and, hopefully, others to use fMRI to observe programmers and, in the long run, answer questions, such as: How should we train programmers? Can we train someone to become an excellent programmer? How effective are new languages and tools for program comprehension?
There is growing diversity in the design of introductory programming environments. Where once all novices learned to program in conventional text-based languages, today, there exists a growing ecosystem of approaches to programming including graphical, tangible, and scaffolded text environments. To date, relatively little work has explored the relationship between the design of novice programming environments and the programming practices they engender in their users. This paper seeks to shed light on this dimension of learning to program through the careful analysis of novice programmers’ experiences learning with a hybrid block/text programming environment. Specifically, this paper is concerned with how novices leverage the various affordances designed into programming environments and programming languages to support their early efforts to author programs. We explore this relationship through the construct of modality using data from a study conducted in a high school computer science classroom in which students spent five weeks working in block-based, text-based, and hybrid block/text programming environments. This paper uses a detailed vignette of a novice writing a program in the hybrid environment as a way to characterize emerging programming practices, then presents analyses of programming trends from the full study population to speak to the generality of the practices identified in the vignette. The analyses focus not only on characterizing authoring strategies but also on identifying patterns in novices’ help-seeking behaviors. By focusing on how modality influences novices’ emerging programming practices, this paper contributes to our understanding of the relationship between programming environment and learning, illuminating the role of design in shaping introductory programming experiences.
In this chapter, we will review the literature on misconceptions about programming, that is, the underdeveloped or flawed ideas that beginners have about specific programming constructs or about the way programs work in general). We will spend much of the chapter looking at examples of common misconceptions and exploring the factors that give rise to them. We will then briefly view misconceptions from the perspective of educational theory before concluding with suggestions on how to address student misconceptions in teaching.
Conference Paper
Blocks-based programming environments are becoming increasingly common in introductory programming courses, but to date, little comparative work has been done to understand if and how this approach affects students' emerging understanding of fundamental programming concepts. In an effort to understand how tools like Scratch and Blockly differ from more conventional text-based introductory programming languages with respect to conceptual understanding, we developed a set of " commutative " assessments. Each multiple-choice question on the assessment includes a short program that can be displayed in either a blocks-based or text-based form. The set of potential answers for each question includes the correct answer along with choices informed by prior research on novice programming misconceptions. In this paper we introduce the Commutative Assessment, discuss the theoretical and practical motivations for the assessment, and present findings from a study that used the assessment. The study had 90 high school students take the assessment at three points over the course of the first ten weeks of an introduction to programming course, alternating the modality (blocks vs. text) for each question over the course of the three administrations of the assessment. Our analysis reveals differences on performance between blocks-based and text-based questions as well as differences in the frequency of misconceptions based on the modality. Future work, potential implications, and limitations of these findings are also discussed.