Missuppfattningar

Vanliga missuppfattningar inom olika områden för programmering.

Sammanfattning av det jag hittat (inför mötet 10/6)

Jag har gjort tre olika sökningar, där jag hittat 14 intressanta artiklar. Det finns fler artiklar som säger samma sak, men valt de som säger mest och som har intressanta/nya vinklar. De vanligaste missförstånden jag hittat är:

Syntaktiska missförstånd, t.ex skillnaden mellan a=b och a==b. Även 2 = a och a = 2.
Variabelmissförstånd. Hur, var och när variabeluttryck utförs av programmet. g = x*x utförs på en gång och sparas som en konstant, det är inte uttrycket som sparas ner i g.
Skillnaden mellan while och for. De ska användas vid olika tillfällen, men studenter hittar oftast en favorit.
Objekt/klasser. Hur klasser fungerar enligt studenter påverkas kraftigt av de första klasserna de ser.
Skillnaden mellan matte-syntax och programmeringssyntax.

Nyckelord för sökningar

Kriterier för valda artiklar

Titeln ska handla om misconceptions och ska helst rikta in sig på python, eller språk som liknar python (men kan också rikta in sig på objekt-orienteradespråk som grupp). Gått ifrån det om abstraktet ser riktigt bra ut.

Ska vara riktat för intro-programmering för gymnasieelever eller högskolestudenter. Valt bort studier som riktat in sig på programmering för grundskolan.

Nu i början har jag valt att fokusera på det som är gjort på denna sida av 2000-talet. Tänker att de som lär sig programmera idag har en annan initial förståelse för datorer, än de som lärde sig programmera på 80-talet.

Har avslutat en sökning när det gått 10 artiklar som säger samma sak, eller 10 artiklar som inte handlar om det jag söker efter

Vissa artiklar har jag valt bort pga att de fokuserar på varför man ska/inte ska använda ett visst språk inom cs1. Kan vara intressant att läsa artiklarna om python senare, men upplever de för subjektiva för skedet vi är i nu.

Vissa artiklar har jag valt bort då dem kretsar kring ett visst verktyg som ska mäta studenternas kunskap m.m, upplever inte att vi tänkt börja använda något sånt och känns som ett helt egen del av det ghär projektet att sätta sig in i alla olika typer av simulationer som finns därute.

Vissa artiklar som verkar intressanta har jag inte åtkomst till. Lagt länkar till dessa, tillsammans med abstrakt, längst ner. FYI.

Celinas kladdpapper

Delar jag vill gå in djupare på

Hur olika textredigerare påverkar studenternas lärande (och minskar missförstånden)
Hur man ska göra labbar som gör ett studenterna får ut så mycket som möjligt från dem (alltså hur ska instruktionerna se ut för att undvika att studenternas kognitiva hjärna inte blir overflowed)
Hur bra exempel ser ut för att täcka för hål och minska missförstånden (exempel för föreläsningar och övningar)
Vad som är bra programmeringsstrategier på en nybörjarnivå (hur man ska lägga upp sin programmering när man ska lösa ett större prolem)
Kan elevernas prestation påverkas om en labb kretsar kring matte? Och hur ska man hjälpa eleverna att skilja på matte och programmering?

Idéer på saker vi kan undersöka i kurserna:

Jag tror det skulle vara intressant att i början av kursen göra något form av test som vi kan samla in data ifrån för att se vad för syntaktiska missförstånd studenterna har. Det här skulle kunna vara ett enkelt quiz (tänk Kahoot typ). Utifrån datan skulle vi kunna se över undervisningen för att se om det är något som brister och som då ökar på de här missförstånden. Det här kanske är något vi har ganska bra koll på redan (vi rättar ju ändå otroligt många labbar och sitter med på många labbtillfällen där vi ser var studenterna gör fel).
En rolig (men kanske inte etiskt korrekt) skulle vara att i en av kurserna rekommendera ett environment, men inte göra det i andra kursen. Utifrån detta se om det blev någon skillnad i problem som dyker upp för studenterna.

Litterära studier

Students’ Misconceptions and Other Difficulties in Introductory Programming: A Literature Review

Students’ Misconceptions and Other Difficulties in Introductory Programming: A Literature Review av YIZHOU QIAN and JAMES LEHMAN (Purdue University):

In this article, we first review relevant literature on general definitions of misconceptions. Second, we review studies about misconceptions and other difficulties that students have in introductory programming. Furthermore, we investigate the factors that contribute to the difficulties. Finally, strategies and tools to address difficulties including misconceptions are discussed.

Based on the review of literature, we found that students exhibit various misconceptions and other difficulties in syntactic knowledge, conceptual knowledge, and strategic knowledge. These difficulties experienced by students are related to many factors including unfamiliarity of syntax, natural language, math knowledge, inaccurate mental models, lack of strategies, programming environments, and teachers’ knowledge and instruction. However, many sources of students’ difficulties have connections with students’ prior knowledge.

Sammanfattning av vad som tas upp (och lite tankar från Celina):

Tre typer av missförstånd:

Syntaktiska missförstånd: Syntaktiskta missförstånd är vanligt. Exempelvis skillnaden på a=b och a==b. Som tur var är ju python snällare när det kommer till syntaxen än java, men det finns ändå några vanliga fallgropar.
Konceptionella missförstånd: Exempel som lyfts i artikeln är hur variabler fungerar (du skriver över dem, de kan bara hålla en sak m.m). Också att variabelnamnen egentligen inte gör något (om du döper en variabel till largest, så kommer inte programmet automatiskt att bara spara det största värdet där). Även hur if/else statements fungerar, loopar m.m. Hur klasser och objekt fungerar är också något som lyfts som ett vanligt problem (något vi alla nog kan känna igen oss i).
Strategiska missförstånd: Hur en ska planera, skriva och felsöka i ett program är något som är svårt för nybörjare. Att få ett problem och dela upp det i mindre problem är också svårt.

Förklaringar till missförstånden:

Task Complexity and Cognitive Load: "Task complexity may contribute to students’ difficulties in programming by increasing students’ cognitive load and leading to confusion (Anderson and Jeffries 1985; Muller et al. 2007; Spohrer and Soloway 1986). As novices who are learning to program are not familiar with all the new terms and syntax of the programming language, they may forget some basic syntactical parts of statements such as parentheses, braces, and semicolons (Altadmri and Brown 2015; Garner et al. 2005; Jackson et al. 2005), or they may confuse basic operators (Sirkia and Sorva 2012; Sleeman et al. 1986) when they write programs. In a study of CS1 students, Sanders and Thomas (2007) found that most of the students submitted flawless programs for the first assignment but when tasks became more challenging, students started to make more syntactic mistakes. By analyzing student errors in programming, Anderson and Jeffries (1985) found that the complexity of the task made students unable to retain information in their working memory and led them to omit necessary parts of the code."
Natural language
Math knowledge
Flawed mental knowledge: Studenter har en bild av hur datorn kommer förstå programmet. "For example, beginners often assume the computer is intelligent like a human being. Pea (1986) found evidence of what he termed a superbug, in which beginning students attributed an intelligence to the computer such that it could interpret what they wished for the computer to do and carry it out. Sleeman et al. (1986) also indicated that a deep error results from students’ belief that computers can think like humans"
Inadequate Patterns and Strategies
Environmental Factors
Teachers’ Instruction and Knowledge: Vad vi säger när vi lär ut kan bidra till missförstånden. "Sometimes teaching itself may contribute to students’ inaccurate mental models; examples of problematic teaching strategies include using inappropriate analogies, models, and metaphors (Taber 2014).". Här tänker jag mycket på vad vi kan råka slänga ur oss under övningar och labbar. Kul om vi kan snappa upp på såna här missförstånd!

Lösningar:

Färdiga exempelprogram. Ju bättre, tydligare och fler exempelprogram vi visar, desto mer kan vi påverka hur studenterna kodar. Artikeln säger "Well-chosen program examples are important, because novice programmers often construct their knowledge from them (Fleury 1991). Example programs should be clear and designed to help students build accurate understanding of programming and improve knowledge transfer.".
Låta eleverna beskriva, förstå och felsöka i färdiga program. Från artikeln " Furthermore, novices usually gain more benefits from worked-out examples than non-novices (Tuovinen and Sweller 1999). Requiring students to read, trace, and explain example programs is also a useful strategy (Mayer 1981; Teague and Lister 2014). Program comprehension is important for writing and debugging code (Lister et al. 2009; Lopez et al. 2008; McCauley et al. 2008). However, novice programmers usually lack program comprehension skills and simply interpret code line by line without seeing the “forest” (Lister et al. 2006; McCauley et al. 2008). Developing learning experiences such as reading and comprehending example programs may help to uncover students’ misconceptions and other difficulties, and develop their skills of writing and debugging code (McCauley et al. 2008; Teague and Lister 2014; Vainio and Sajaniemi 2007).
Få studenterna att använda environments som hjälper dem. Om studenterna använder sig av t.ex Pycharm så kan de få hjälp med t.ex syntaxproblem och slipper sitta fast (något artikeln lyfter). En annan tanke jag fick när jag läste var hur personer med dyslexi gynnas av environments som auto-avslutar det man skriver. OBS! Inget artikeln har undersökt.
Hjälpprogram som hjälper studenterna att förstå hur koden exekveras. Det finns en del hemsidor som tydligt visar hur varje kodrad exekveras och det här kan hjälpa studenterna att utveckla sin "conceptional knowledge". En sida som jag använt och som även lyfts i artikeln är Online Python Tutor (https://pythontutor.com/render.html#mode=display).
Lära ut programmeringsstrategier. "After receiving explicit instruction in programming strategies, de Raadt (2008) indicated that students exhibited improved performance in programming and an increase in the ability to apply strategies while solving problems."
Peer instruction. "PI is an instructional approach to engage students in building their own understanding of concepts using three steps: individually answering a question, discussing the question with peers, and responding to the question again (Simon et al. 2010)."
Conceptual Change Theories

Experimentella studier

Avoiding Object Misconceptions

Avoiding Object Misconceptions av Simon Holland, Robert Griffiths, Mark Woodman (The Open University)

This paper has identified and characterized several misconceptions observed in students learning about object concepts, and has described simple teaching measures to avoid them. Pedagogical issues have been discussed of particular importance when constructing teaching or assessment examples.

Kommentar om artikeln: Den här undersökningen är gjord på en hyfsat liten grupp av studenter, men det de fått fram tycker jag ändå går att använda vidare och kika mer på. Lyft de delar jag tyckte var mest intressant. Den är ganska "hands-on" artikeln, finns nog mer att hitta på ämnet som gör att vi får en bättre bild. Det som fick mig att fastna lite extra är också att jag upplevde att vi i höstas gjorde många av de fel som nämns i artikeln (just angående klasser), vilket gjorde att studenterna hade det svårt när de kom till p-uppgiften.

Viktiga delar från artikeln:

De första klassexemplena som studenterna ser kommer att påverka deras bild av klasser och kan riskera att skapa stora missförstånd. Viktigt att de första klasserna de ser inte är för snarlika och framförallt att de inte är för simplifierade.
Artikeln lyfter en viktig aspekt angående vilka attribut de första klasserna studenterna ser har. Att det kanske inte är så bra om den har två attribut som båda är av samma typ, då det kan ses som en finare inpackning av en variabel.
Inte ge bilden av att klasser bara är databaser
Hur instanser av en klass sparas ner. Viktigt att visa olika sätt att spara objektreferenser på. Att en referens till ett objekt kan sparas i flera olika variabler, att en referens kan skrivas över, att ett objekts attribut inte är kopplade till variabelnamnet osv.

Learnersourcing at Scale to Overcome Expert Blind Spots for Introductory Programming: A Three-Year Deployment Study on the Python Tutor Website

Learnersourcing at Scale to Overcome Expert Blind Spots for Introductory Programming: A Three-Year Deployment Study on the Python Tutor Website av Philip J. Guo, Julia M. Markel, Xiong Zhang

It is hard for experts to create good instructional resources due to a phenomenon known as the expert blind spot: They forget what it was like to be a novice, so they cannot pinpoint exactly where novices commonly struggle and how to best phrase their explanations. To help overcome these expert blind spots for computer programming topics, we created a learnersourcing system that elicits explanations of misconceptions directly from learners while they are coding. We have deployed this system for the past three years to the widely-used Python Tutor coding website (pythontutor.com) and collected 16,791 learner-written explanations. To our knowledge, this is the largest dataset of explanations for programming misconceptions. By inspecting this dataset, we found surprising insights that we did not originally think of due to our own expert blind spots as programming instructors. We are now using these insights to improve compiler and run-time error messages to explain common novice misconceptions.

Kommentar om artikeln: Kul grej! Tyvärr fokuserar den bara på syntax, vilket är något som jag iallafall inte tror är/kommer vara vårt största problem. Men kul läsning fick jag!

Identifying and Addressing Common Programming Misconceptions with Variables (Part 1)

Identifying and Addressing Common Programming Misconceptions with Variables (Part 1) av Danny Plass-Oude Bos, PhD (University of Twente)

Programming is considered an important skill for the 21st century, but it is not an easy skill to teach or to learn. One of the most basic concepts in programming is that of variables. Students’ understanding can be obstructed by a wide range of incorrect ideas of how variables work. These misconceptions mostly originate from previous experiences with math (demonstrated by 83% of our participant population), human interaction (34%), the container analogy (5%), and misunderstanding semantics (39%). To help both students and teachers, we developed an overview of common misconceptions around variables, a test to help identify them, and an interactive video to help transform them into the correct way of thinking. An evaluation with secondary education and applied university students resulted in a significant improvement in the misconception test scores, possibly caused by the intervention. The misconceptions overview has been extended with additional misconceptions we consistently observed in practice.

Kommentar om artikeln: Den här var svårläst. De missförstånden som tas upp nämns redan i "Students’ Misconceptions and Other Difficulties in Introductory Programming: A Literature Review" och "Learnersourcing at Scale to Overcome Expert Blind Spots for Introductory Programming". Det nya den här artikeln bidrar med är reflektionerna som kommer med förklaringen av videon. De här reflektionerna är dock inte inom vårt "scope".

Identifying Novice Student Programming Misconceptions and Errors From Summative Assessments

Identifying Novice Student Programming Misconceptions and Errors From Summative Assessments av Ashok Kumar Veerasamy, Daryl D’Souza and Mikko-Jussi Laakso (Journal of Educational Technology)

This article presents a study aimed at examining the novice student answers in an introductory programming final e-exam to identify misconceptions and types of errors. Our study used the Delphi concept inventory to identify student misconceptions and skill, rule, and knowledge-based errors approach to identify the types of errors made by novices in Python programming. The students’ responses to each question were scrutinized by using the Delphi concept inventory, heuristic-analytic theory, and neo-Piagetian theory of cognitive development for qualitative data analysis. Moreover, the motivation for this exploratory study was to also address the misconceptions that students held in programming and help educators to redefine the teaching methods to correct those alternative conceptions. Student misconceptions were spotted in list referencing and inbuilt functions in Python. In a further quantitative analysis, the study found that students who had misconceptions made knowledge errors and failed to complete the coding tasks. Surprisingly, and coincidentally, it was identified that only a few students were able to write code related to mathematical problems.

Kommentar om artikeln: Jag tyckte om hur den delade upp misstag under examinationen i tre delar; skill-based errors, rule-based errors och knowledge-based errors. De kategoriserade elevernas misstag utifrån vad eleven hade gjort för misstag, var misstaget skett och om liknande misstag gjorts av eleven. Det här är intressant för att kunna mappa hela elevgruppens kunskap och se var kursen brister. I studien såg de en hel del knowledge-based errors, t.ex return-värdet från funktioner blev fel för många och indexeringen av listor blev svårt. Vad jag hittar så hittade de inga nya misstag/missförstånd som inte tidigare studier hittat. Deras studie gjordes också bara på 39 elever i samma kursomgång, så den är ju inte särskilt täckande. De drar inte heller några kopplingar mellan misstagen eleverna gjort och vanliga missförstånd som kan ske, utan nämner det i "framtida forskning" avsnittet: " Further research could be conducted to measure the correlation between type of errors committed by student and student misconceptions". De nämner i abstractet också att den ska vara till en hjälp för lärare att ändra sina metoder för att hjälpa eleverna, men tycker ärligt talat inte studien är till så stor hjälp. MEN! Något intressant de hitta var att eleverna hade svårare att lösa uppgifter som involverade matematik, det här är något som kan vara intressant att kika på för våra kurser, då många av labbarna kretsar kring just matte. I "framtida forskning" säger de att det skulle vara intressant att se om det kan ha att göra med "matte-ångest", vilket jag också tycker låter spännande!

Variable Evaluation: an Exploration of Novice Programmers’ Understanding and Common Misconceptions

Variable Evaluation: an Exploration of Novice Programmers’ Understanding and Common Misconceptions av Tobias Kohn

For novice programmers one of the most problematic concepts is variable assignment and evaluation. Several questions emerge in the mind of the beginner, such as what does x = 7 + 4 or x = x + 1 really mean? For instance, many students initially think that such statements store the entire calculation in variable x, evaluating the result lazily when actually needed. The common increment pattern x = x + 1 is even believed to be outright impossible. This paper discusses a multi-year project examining how high school students think of assignments and variables. In particular, where does the misconception of storing entire calculations come from? Can we explain the students' thinking and help them develop correct models of how programming works? It is particularly striking that a model of the computer as a machine with algebraic capabilities would indeed produce the observed misconceptions. The misconception might simply be attributed to the expectation that the computer performs computations the exact same way students are taught to in mathematics.

Kommentar om artikeln:

Det här var en intressant artikeln, då den fördjupar sig i hur en elevs mattekunskaper kan skapa problem när de ska lära sig programmera. Studien är gjord på gymnasieelever, men jag tänker att det ändå är applicerbart på våra studenter, då de oftast ändå kommer direkt från gymnasiet och oftast inte har programmerat tidigare. Artikeln fokuserar på variabler och hur variabler i programmering skiljer sig från variabler i python. Den fokuserar på tre olika delar i variabler (kopierat direkt från artikeln):

Syntax. Some students believe that assignments are symmetric, i. e. x = 2 and 2 = x are both valid. Others believe that a variable’s name determines its contents, e. g., that a variable called “max” will automatically hold the maximum value of a list.

The Nature of Variables. Variables are sometimes seen as boxes that can hold more than one value or have a memory. Some students also think that after a variable has been accessed, it is “empty” afterwards. An interesting misconception is that variables hold unevaluated expressions such as 2 + 3 or x The actual value would then be computed when the variable’s value is accessed. This notion is discussed in detail in this paper.

Assignments. Due to the syntactical similarity with equations, some students believe that assignments are actual equations to be solved by the computer. Others believe that an assignment such as x = y links the two variables together, so that x and y will always hold the same value. This last misconception of x = y linking x and y together becomes much more relevant when references are introduced. For instance, in Python x and y might indeed be linked together if y is a list. Interestingly, some students believe that the entire “equation” is stored. This misconception is very similar to the notion that a variable holds the entire unevaluated expression. The difference between this misconception and the idea that a variable holds an unevaluated expression might lie in that some students do not think in terms of variables at all but assume that the computer stores equations independently of variables.

De här tre delarna tycker jag verkar viktiga även för våra kurser och kan vara bra delar att visualisera för studenterna redan från början av kursen (vet att jag själv sett dessa problem och att jag tagit upp delar av det som exempel för studenterna på övningar/labbtillfällen.

Ett annat intressant stycke från artikeln som jag tycker är värt att nämna är: "Of particular importance are the answers to problem [P4]. They show that, indeed, some students’ mental models of the evaluation and assignment of variables are wrong. Roughly a third of the students seems to have assumed that an assignment is evaluated lazily at the time when the variable’s value is actually used."

Det här är resultatdiskussion utifrån elevernas svar på denna uppgift:

x = 5

def f(x):

return x∗x

g = x∗x

x = 8

print f(2)

print f(x)

print g

Där eleverna hade svårt att svara på vad print f(x) och print g skulle ge för resultat.

Teaching Python programming to novices: Addressing misconceptions and creating a development environment

Del av abstrakt: One of the great challenges in teaching to program is to help students understand how programming actually works. Students unavoidably develop misconceptions during their learning process, which must be corrected through skillful feedback. Such misconceptions reach from rather simple syntactical problems to deep underlying misunderstandings about what a computational machine is, and how it works. With the objective to assist the students in developing correct mental models, we must understand these misconceptions, and how to correct them.

Kommentar: Det här är ju då en bok och inte en artikel. Imorgon tänkte jag gräva ner mig i dessa 120 sidor, abstraktet ser iallafall lovande ut!

Tracing quiz set to identify novices' programming misconceptions

Tracing quiz set to identify novices' programming misconceptions av Takayuki Sekiya, Kazunori Yamaguchi

Novice programmers' understanding of conditional and loop constructs are often incomplete. They seem to understand a single conditional or single loop, but fail to understand the combination of them. We propose a method for finding misconceptions underlying this failure. We first developed a tracing quiz set to locate the exact points at which students will fail. Second, we identified some misconceptions from experiments on five courses. Third, to use and validate these misconceptions, we developed an interactive test system which showed the correct answers to the students and requested them to describe their explanations. The experiments showed that some misconceptions affected the overall performance of the students.

Kommentar om artikeln: Okej, den här studien är gjord på studenter som lär sig programmera mha ruby, så nog bra om man hittar en till studie som hittat samma svårigheter på ämnet loopar och if-satser. Men det här är de sju svårigheter de hitta hos studenterna, där NFL är den som var vanligast:

CVIC Change Variable In Condition - Interpret variables in the conditional part of conditionals as control variables.

CVIC2 Change Variable In Condition 2 - Interpret variables in the conditional part of conditionals as the end value of the enclosing loop.

CVIL: Change Variable In Loop - Interpret variables in conditionals as control variables.

CVIL2 Change Variable In Loop 2 - Interpret variables in conditionals as the end value of the enclosing loop.

CVISL Change Variable In Simple Loop - Interpret variables in the body of conditionals as control variables.

NFL Neglect(ignore) For Loop- Ignore loop when the body has no control variables.

RAA Regard As Array - Interpret substitution to keep the previous values.

Utöver detta så går den mest in på tracing quizzet de skapat, vilket inte är applicerbart för oss (förutom inspo om vi vill göra ett test).

37 Million Compilations: Investigating Novice Programming Mistakes in Large-Scale Student Data

37 million compilations: Investigating novice programming mistakes in large-scale student data av Amjad Altadmri, Neil C.C. Brown

Previous investigations of student errors have typically focused on samples of hundreds of students at individual institutions. This work uses a year's worth of compilation events from over 250,000 students all over the world, taken from the large Blackbox data set. We analyze the frequency, time-to-fix, and spread of errors among users, showing how these factors inter-relate, in addition to their development over the course of the year. These results can inform the design of courses, textbooks and also tools to target the most frequent (or hardest to fix) errors.

Kommentar om artikeln: Tycker om det här! De har väldigt mycket data och man kan tydligt se vilka fel som görs ofta. De har inte dragit några kopplingar till missförstånden och avsaknaden av en djupare förståelse, men det är ju sånt man kan sitta och filosofera över! Det jag tycker är mest intressant med denna artikel är att det dyker upp såna misstag/missförstånd som inte nämnts i tidigare artiklar (t.ex. 1.). Studien är gjord i java, vilket gör att en hel del av misstagen inte kan göras i python. Tagit med de misstagen som gjordes ofta och som kan göras i python också. Rangordnat de efter hur många ggr misstaget gjordes. OBS! Studien är hyfsat påverkad av att man redan innan valt ut vilka misstag man vill kika på. Kan finnas andra misstag som görs oftare men som inte fångades upp pga detta.

C: Unbalanced parentheses, curly or square brackets and quotation marks, or using these different symbols interchangeably. For example: while (a == 0]

I: Invoking methods with wrong arguments (e.g. wrong types). For example: list.get("abc")

A: Confusing the assignment operator (=) with the comparison operator (==). For example: if (a = b) ...

N: A method that has a non-void return type is called and its return value ignored/discarded. For example: myObject.toString();

Q: Incompatible types between method return and type of variable that the value is assigned to. For example: int x = myObject.toString();

J: Forgetting parentheses after a method call. For example: myObject.toString;

Programming Misconceptions in an Introductory Level Programming Course Exam

Programming misconceptions in an introductory level programming course exam av Einari Kurvinen, Niko Hellgren, Erkki Kaila, Mikko-Jussi Laakso, Tapio Salakoski

Learning to program is known to be a difficult task, as the students typically lack the intrinsic motivation and find the new skills required difficult to master. It is hence typical for the educators to try to constantly improve their teaching methods to enhance the quality and outcome of the courses. We have developed an educational tool called ViLLE, which allows us to create interactive and automatically assessed programming exercises easily. In these exercises, the students have a near-to-authentic programming environment with compiler output and error messages provided. The same tool was used in our university's introductory programming course's final exam. In this paper, we analyze students' answers to three different coding exercises in this final exam. Since ViLLE automatically stores the program code when compiled, we have an access to previously unseen amounts of iterations of the exercise instead of just the final submission. The data is analyzed to identify typical misconceptions in programming exercises, and to show how the students gradually improve their answers based on the results and error messages. Finally, we discuss how the results of the analysis can be utilized to tackle these misconceptions during the course.

Kommentar om artikeln: Inget nytt här. Studien gjordes på 9 (??) studenter i java och missförstånden som hittades var detsamma som andra studier hittat. Inga nya reflektioner värda att nämnas.

Identifying student misconceptions of programming

Identifying student misconceptions of programming av Lisa C. Kaczmarczyk, Elizabeth R. Petrick, J. Philip East, Geoffrey L. Herman

Computing educators are often baffled by the misconceptions that their CS1 students hold. We need to understand these misconceptions more clearly in order to help students form correct conceptions. This paper describes one stage in the development of a concept inventory for Computing Fundamentals: investigation of student misconceptions in a series of core CS1 topics previously identified as both important and difficult. Formal interviews with students revealed four distinct themes, each containing many interesting misconceptions. Three of those misconceptions are detailed in this paper: two misconceptions about memory models, and data assignment when primitives are declared. Individual misconceptions are related, but vary widely, thus providing excellent material to use in the development of the CI. In addition, CS1 instructors are provided immediate usable material for helping their students understand some difficult introductory concepts.

Kommentar om artikeln: Tar inte upp några nya grejer. Fokuserar mycket på minne, vilket inte är något vi fokuserar på under kursen. Studien är fokuserad på java.

Thinking out of the box: comparing metaphors for variables in programming education

Thinking out of the box: comparing metaphors for variables in programming education av Felienne Hermans, Alaaeddin Swidan, Efthimia Aivaloglou, Marileen Smit

When teaching novices programming, misconceptions can occur. Misconception are incorrect beliefs about certain programming concept. For example, some novices think that a variable can hold multiple values, in the case of two consecutive assignment statements, such as x = 5; x = 7. While explaining variables introductory materials often use the metaphor of a box for a variable, which might contribute to the 'multiple values' hypothesis. To investigate this, we design and run a controlled experiment with 496 novice programmers, both children and adults. Half of our participants receive an introductory programming lesson in which we explain a variable as a box, while the other half of participants receive the explanation of a variable as being a label. They are subsequently questioned about their understanding of variables. Our results show that, for the simple questions involving one assignment, the box group performs better. However, for questions involving the misconception --- with two consecutive assignment statements --- the label group outperforms the box group. This however primarily occurs when considering variables of type string, for integers subjects interpret the statements as numeric values to be added.

Kommentar: Det som beskrivs i abstraktet är en utveckling av det som nämns snabbt i "Students’ Misconceptions and Other Difficulties in Introductory Programming: A Literature Review", därför jag fastnade på den. Det de kommer fram till är att metaforen att en variabel är som en låda kan skapa problem när man assignar flera värden till en variabel, då en låda tekniskt sätt kan innehålla flera saker. Om man istället använder att en variabel är en label för ett värde så är det färre som har svårt med just det. Dock verkar förståelsen bli bättre med första metaforen. Viktigt här att säga är att den här studien är gjord på barn och föräldrar i ett museum och att det är scratch som används i programmeringsspråk. Det som skulle vara intressant att söka vidare på är vilken metafor som är bäst för att beskriva olika koncept i python.

An analysis of patterns of debugging among novice computer science students

The process by which students learn to program is a major issue in computer science educational research. Programming is a fundamental part of the computer science curriculum, but one which is often problematic. It seems to be difficult to find an effective method of teaching that is suitable for all students. In this research we tried to gain insights into ways of improving our teaching by a careful examination of students' mistakes. The compiler errors that were generated by their programs together with the pattern that was observed in their debugging activities formed the basis of this research. We discovered that many students with a good understanding of programming do not acquire the skills to debug programs effectively, and this is a major impediment to their producing working code of any complexity. Skill at debugging seems to increase a programmer's confidence and we suggest that more emphasis be placed on debugging skills in the teaching of programming.