{
    "componentChunkName": "component---src-templates-reference-js",
    "path": "/reference/rodrigoAnAnalysisOfJavaProgramming2013/",
    "result": {"data":{"zoteroItems":{"citationKey":"rodrigoAnAnalysisOfJavaProgramming2013","data":{"key":"FR5FQA49","version":116,"itemType":"journalArticle","title":"An Analysis of Java Programming Behaviors, Affect, Perceptions, and Syntax Errors among Low-Achieving, Average, and High-Achieving Novice Programmers","abstractNote":"In this article we quantitatively and qualitatively analyze a sample of novice programmer compilation log data, exploring whether (or how) low-achieving, average, and high-achieving students vary in their grasp of these introductory concepts. High-achieving students self-reported having the easiest time learning the introductory programming topics. In a quantitative analysis, though, high-achieving and average students were: 1) more effective at debugging (on average, as quantified by Jadud's Error Quotient (EQ)) than low-achieving students; and 2) were least confused, as quantified using Lee's confusion metric. However, the differences in EQ and confusion between groups were not statistically significant. This implied that all groups struggled with programming to similar extents. This finding was further supported by was used to delineate two sets of variables. The results indicate that preference for autonomy in computer science learning positively predicts selfefficacy in learning computer science with the strongest coefficient. Computer science learner preference for teacher control is also a positive predictor. However, preference for participation in managing the computer class and preference for depending on the teacher did not play a significant role in the students' self-efficacy in learning computer science.","date":"10/2013","proceedingsTitle":null,"conferenceName":null,"thesisType":null,"university":null,"place":"","publisher":"","volume":"49","pages":"293-325","series":"","language":"en","DOI":"10.2190/EC.49.3.b","ISBN":null,"shortTitle":"","url":"https://journals.sagepub.com/doi/10.2190/EC.49.3.b","accessDate":"2025.11.16","archive":"","archiveLocation":"","libraryCatalog":"DOI.org (Crossref)","callNumber":"","rights":"","extra":"","dateAdded":"2025-11-16T13:17:48Z","dateModified":"2025-11-16T14:09:19Z","reportNumber":null,"reportType":null,"seriesTitle":"","institution":null,"publicationTitle":"Journal of Educational Computing Research","issue":"3","seriesText":"","journalAbbreviation":"Journal of Educational Computing Research","ISSN":"0735-6331, 1541-4140","bookTitle":null,"seriesNumber":null,"numberOfVolumes":null,"edition":null,"creators":[{"creatorType":"author","firstName":"Ma. Mercedes T.","lastName":"Rodrigo"},{"creatorType":"author","firstName":"Thor Collin S.","lastName":"Andallaza"},{"creatorType":"author","firstName":"Francisco Enrique Vicente G.","lastName":"Castro"},{"creatorType":"author","firstName":"Marc Lester V.","lastName":"Armenta"},{"creatorType":"author","firstName":"Thomas T.","lastName":"Dy"},{"creatorType":"author","firstName":"Matthew C.","lastName":"Jadud"}],"tags":[],"parsedDate":"2013","creatorSummary":"Rodrigo et al."}},"misconceptions":{"totalCount":247,"edges":[{"node":{"slug":"misconceptions/Java/AbstractClassMustImplementAbstractMethod/","fields":{"slug":"/misconceptions/Java/AbstractClassMustImplementAbstractMethod/","name":"AbstractClassMustImplementAbstractMethod","pl":"Java"},"frontmatter":{"shortDescription":"An abstract class must implement all abstract methods defined in its superclass"}}},{"node":{"slug":"misconceptions/Java/AbstractClassNoImplementation/","fields":{"slug":"/misconceptions/Java/AbstractClassNoImplementation/","name":"AbstractClassNoImplementation","pl":"Java"},"frontmatter":{"shortDescription":"An abstract class cannot contain implemented methods"}}},{"node":{"slug":"misconceptions/Java/AddMemberAtRuntime/","fields":{"slug":"/misconceptions/Java/AddMemberAtRuntime/","name":"AddMemberAtRuntime","pl":"Java"},"frontmatter":{"shortDescription":"Set of class members can change at runtime"}}},{"node":{"slug":"misconceptions/Java/AllClassesHaveDefaultConstructor/","fields":{"slug":"/misconceptions/Java/AllClassesHaveDefaultConstructor/","name":"AllClassesHaveDefaultConstructor","pl":"Java"},"frontmatter":{"shortDescription":"All classes automatically get a no-argument constructor"}}},{"node":{"slug":"misconceptions/Java/AnyClassException/","fields":{"slug":"/misconceptions/Java/AnyClassException/","name":"AnyClassException","pl":"Java"},"frontmatter":{"shortDescription":"Any class can be an exception class"}}},{"node":{"slug":"misconceptions/Java/ArithmeticPlusPrecedes/","fields":{"slug":"/misconceptions/Java/ArithmeticPlusPrecedes/","name":"ArithmeticPlusPrecedes","pl":"Java"},"frontmatter":{"shortDescription":"Addition has higher precedence than string concatenation"}}},{"node":{"slug":"misconceptions/Java/ArrayAccessWithParentheses/","fields":{"slug":"/misconceptions/Java/ArrayAccessWithParentheses/","name":"ArrayAccessWithParentheses","pl":"Java"},"frontmatter":{"shortDescription":"Parentheses are used to access an element in an array"}}},{"node":{"slug":"misconceptions/Java/ArrayAllocationWithoutNew/","fields":{"slug":"/misconceptions/Java/ArrayAllocationWithoutNew/","name":"ArrayAllocationWithoutNew","pl":"Java"},"frontmatter":{"shortDescription":"Arrays are created without the new keyword"}}},{"node":{"slug":"misconceptions/Java/ArrayBracketCountIsLength/","fields":{"slug":"/misconceptions/Java/ArrayBracketCountIsLength/","name":"ArrayBracketCountIsLength","pl":"Java"},"frontmatter":{"shortDescription":"The number of brackets in an array type or an array initializer corresponds to the length of the array"}}},{"node":{"slug":"misconceptions/Java/ArrayElementTypeRepeats/","fields":{"slug":"/misconceptions/Java/ArrayElementTypeRepeats/","name":"ArrayElementTypeRepeats","pl":"Java"},"frontmatter":{"shortDescription":"The type of a multi-dimensional array is written as T[] T[] T[]"}}},{"node":{"slug":"misconceptions/Java/ArrayElementsUntyped/","fields":{"slug":"/misconceptions/Java/ArrayElementsUntyped/","name":"ArrayElementsUntyped","pl":"Java"},"frontmatter":{"shortDescription":"Elements of arrays are untyped"}}},{"node":{"slug":"misconceptions/Java/ArrayHasLengthMethod/","fields":{"slug":"/misconceptions/Java/ArrayHasLengthMethod/","name":"ArrayHasLengthMethod","pl":"Java"},"frontmatter":{"shortDescription":"To get the length of an array, one needs to call its length method"}}},{"node":{"slug":"misconceptions/Java/ArrayInitializerContentsInBrackets/","fields":{"slug":"/misconceptions/Java/ArrayInitializerContentsInBrackets/","name":"ArrayInitializerContentsInBrackets","pl":"Java"},"frontmatter":{"shortDescription":"Array initializers list the elements in square brackets"}}},{"node":{"slug":"misconceptions/Java/ArrayLengthCannotBeZero/","fields":{"slug":"/misconceptions/Java/ArrayLengthCannotBeZero/","name":"ArrayLengthCannotBeZero","pl":"Java"},"frontmatter":{"shortDescription":"An array cannot have a length of 0 elements"}}},{"node":{"slug":"misconceptions/Java/ArrayLengthPartOfType/","fields":{"slug":"/misconceptions/Java/ArrayLengthPartOfType/","name":"ArrayLengthPartOfType","pl":"Java"},"frontmatter":{"shortDescription":"The length of an array is part of its type"}}},{"node":{"slug":"misconceptions/Java/ArrayListIsArray/","fields":{"slug":"/misconceptions/Java/ArrayListIsArray/","name":"ArrayListIsArray","pl":"Java"},"frontmatter":{"shortDescription":"ArrayLists are arrays"}}},{"node":{"slug":"misconceptions/Java/ArrayRankIsLength/","fields":{"slug":"/misconceptions/Java/ArrayRankIsLength/","name":"ArrayRankIsLength","pl":"Java"},"frontmatter":{"shortDescription":"Array rank and array length are the same thing"}}},{"node":{"slug":"misconceptions/Java/ArrayRankNotPartOfType/","fields":{"slug":"/misconceptions/Java/ArrayRankNotPartOfType/","name":"ArrayRankNotPartOfType","pl":"Java"},"frontmatter":{"shortDescription":"The rank of an array is not part of its type"}}},{"node":{"slug":"misconceptions/Java/ArraysGrow/","fields":{"slug":"/misconceptions/Java/ArraysGrow/","name":"ArraysGrow","pl":"Java"},"frontmatter":{"shortDescription":"Arrays can grow dynamically"}}},{"node":{"slug":"misconceptions/Java/AssignCompares/","fields":{"slug":"/misconceptions/Java/AssignCompares/","name":"AssignCompares","pl":"Java"},"frontmatter":{"shortDescription":"= compares two values"}}},{"node":{"slug":"misconceptions/Java/AssignmentCopiesObject/","fields":{"slug":"/misconceptions/Java/AssignmentCopiesObject/","name":"AssignmentCopiesObject","pl":"Java"},"frontmatter":{"shortDescription":"Assignment copies the object"}}},{"node":{"slug":"misconceptions/Java/AssignmentNotExpression/","fields":{"slug":"/misconceptions/Java/AssignmentNotExpression/","name":"AssignmentNotExpression","pl":"Java"},"frontmatter":{"shortDescription":"An assignment a=b is not an expression"}}},{"node":{"slug":"misconceptions/Java/BaseCaseNotNeeded/","fields":{"slug":"/misconceptions/Java/BaseCaseNotNeeded/","name":"BaseCaseNotNeeded","pl":"Java"},"frontmatter":{"shortDescription":"Recursive computations do not necessarily need a base case"}}},{"node":{"slug":"misconceptions/Java/BaseCaseSelfRecursive/","fields":{"slug":"/misconceptions/Java/BaseCaseSelfRecursive/","name":"BaseCaseSelfRecursive","pl":"Java"},"frontmatter":{"shortDescription":"The base case of a structural recursion consists of a recursive self-call"}}},{"node":{"slug":"misconceptions/Java/CallNotStaticallyChecked/","fields":{"slug":"/misconceptions/Java/CallNotStaticallyChecked/","name":"CallNotStaticallyChecked","pl":"Java"},"frontmatter":{"shortDescription":"A method invocation on a reference of a type that does not have that method won't compile"}}},{"node":{"slug":"misconceptions/Java/CallOnPrimitive/","fields":{"slug":"/misconceptions/Java/CallOnPrimitive/","name":"CallOnPrimitive","pl":"Java"},"frontmatter":{"shortDescription":"One can invoke a method on primitive values"}}},{"node":{"slug":"misconceptions/Java/CallRequiresVariable/","fields":{"slug":"/misconceptions/Java/CallRequiresVariable/","name":"CallRequiresVariable","pl":"Java"},"frontmatter":{"shortDescription":"One needs a variable to invoke a method"}}},{"node":{"slug":"misconceptions/Java/CallWithoutFrame/","fields":{"slug":"/misconceptions/Java/CallWithoutFrame/","name":"CallWithoutFrame","pl":"Java"},"frontmatter":{"shortDescription":"A method invocation does not necessarily allocate a stack frame"}}},{"node":{"slug":"misconceptions/Java/CallerFrameContainsCalleeFormal/","fields":{"slug":"/misconceptions/Java/CallerFrameContainsCalleeFormal/","name":"CallerFrameContainsCalleeFormal","pl":"Java"},"frontmatter":{"shortDescription":"Stack frame of caller includes variables for callee's formal parameters"}}},{"node":{"slug":"misconceptions/Java/CannotChainMemberAccesses/","fields":{"slug":"/misconceptions/Java/CannotChainMemberAccesses/","name":"CannotChainMemberAccesses","pl":"Java"},"frontmatter":{"shortDescription":"Member accesses cannot be chained together"}}},{"node":{"slug":"misconceptions/Java/CannotChainMemberToConstructor/","fields":{"slug":"/misconceptions/Java/CannotChainMemberToConstructor/","name":"CannotChainMemberToConstructor","pl":"Java"},"frontmatter":{"shortDescription":"Method calls or field accesses cannot be chained to a constructor invocation"}}},{"node":{"slug":"misconceptions/Java/CatchAlwaysExecutes/","fields":{"slug":"/misconceptions/Java/CatchAlwaysExecutes/","name":"CatchAlwaysExecutes","pl":"Java"},"frontmatter":{"shortDescription":"Catch blocks always get executed"}}},{"node":{"slug":"misconceptions/Java/CatchProvidesOptions/","fields":{"slug":"/misconceptions/Java/CatchProvidesOptions/","name":"CatchProvidesOptions","pl":"Java"},"frontmatter":{"shortDescription":"Only the part of a catch block necessary to fix the cause of an exception is executed"}}},{"node":{"slug":"misconceptions/Java/ChainedMethodsNotCalledFromOutside/","fields":{"slug":"/misconceptions/Java/ChainedMethodsNotCalledFromOutside/","name":"ChainedMethodsNotCalledFromOutside","pl":"Java"},"frontmatter":{"shortDescription":"Chained methods are all called on the object at the beginning of the chain"}}},{"node":{"slug":"misconceptions/Java/CharNotNumeric/","fields":{"slug":"/misconceptions/Java/CharNotNumeric/","name":"CharNotNumeric","pl":"Java"},"frontmatter":{"shortDescription":"Char is not a numeric type"}}},{"node":{"slug":"misconceptions/Java/ComparisonWithBooleanLiteral/","fields":{"slug":"/misconceptions/Java/ComparisonWithBooleanLiteral/","name":"ComparisonWithBooleanLiteral","pl":"Java"},"frontmatter":{"shortDescription":"To test whether an expression is true or false, one must compare it to true or to false"}}},{"node":{"slug":"misconceptions/Java/CompositeExpressionsUntyped/","fields":{"slug":"/misconceptions/Java/CompositeExpressionsUntyped/","name":"CompositeExpressionsUntyped","pl":"Java"},"frontmatter":{"shortDescription":"Expressions that consist of multiple parts have no type"}}},{"node":{"slug":"misconceptions/Java/ConcreteClassMustOverride/","fields":{"slug":"/misconceptions/Java/ConcreteClassMustOverride/","name":"ConcreteClassMustOverride","pl":"Java"},"frontmatter":{"shortDescription":"A concrete class needs to implement all abstract methods and override all concrete methods declared in its abstract superclasses"}}},{"node":{"slug":"misconceptions/Java/ConcreteClassOnlyImplementClassAbstract/","fields":{"slug":"/misconceptions/Java/ConcreteClassOnlyImplementClassAbstract/","name":"ConcreteClassOnlyImplementClassAbstract","pl":"Java"},"frontmatter":{"shortDescription":"A concrete class only needs to implement those abstract methods it inherits from abstract superclasses"}}},{"node":{"slug":"misconceptions/Java/ConcreteClassOnlyImplementDirectAbstract/","fields":{"slug":"/misconceptions/Java/ConcreteClassOnlyImplementDirectAbstract/","name":"ConcreteClassOnlyImplementDirectAbstract","pl":"Java"},"frontmatter":{"shortDescription":"A concrete class only needs to implement abstract methods declared in its direct supertypes"}}},{"node":{"slug":"misconceptions/Java/ConcreteClassOnlyImplementInterfaceAbstract/","fields":{"slug":"/misconceptions/Java/ConcreteClassOnlyImplementInterfaceAbstract/","name":"ConcreteClassOnlyImplementInterfaceAbstract","pl":"Java"},"frontmatter":{"shortDescription":"A concrete class only needs to implement those abstract methods it inherits from interfaces"}}},{"node":{"slug":"misconceptions/Java/ConditionalIsSequence/","fields":{"slug":"/misconceptions/Java/ConditionalIsSequence/","name":"ConditionalIsSequence","pl":"Java"},"frontmatter":{"shortDescription":"If-else is equivalent to sequence of two ifs"}}},{"node":{"slug":"misconceptions/Java/ConstructorAllocates/","fields":{"slug":"/misconceptions/Java/ConstructorAllocates/","name":"ConstructorAllocates","pl":"Java"},"frontmatter":{"shortDescription":"The constructor allocates the object"}}},{"node":{"slug":"misconceptions/Java/ConstructorParameterIsField/","fields":{"slug":"/misconceptions/Java/ConstructorParameterIsField/","name":"ConstructorParameterIsField","pl":"Java"},"frontmatter":{"shortDescription":"Formal constructor parameters are equivalent to instance variables"}}},{"node":{"slug":"misconceptions/Java/ConstructorReturnsObject/","fields":{"slug":"/misconceptions/Java/ConstructorReturnsObject/","name":"ConstructorReturnsObject","pl":"Java"},"frontmatter":{"shortDescription":"Constructors need to return objects"}}},{"node":{"slug":"misconceptions/Java/ConstructorWithoutNew/","fields":{"slug":"/misconceptions/Java/ConstructorWithoutNew/","name":"ConstructorWithoutNew","pl":"Java"},"frontmatter":{"shortDescription":"One can write the constructor name, without new, to instantiate a class"}}},{"node":{"slug":"misconceptions/Java/ControlledLocalAccess/","fields":{"slug":"/misconceptions/Java/ControlledLocalAccess/","name":"ControlledLocalAccess","pl":"Java"},"frontmatter":{"shortDescription":"One can control access to local variables using access modifiers"}}},{"node":{"slug":"misconceptions/Java/DeferredReturn/","fields":{"slug":"/misconceptions/Java/DeferredReturn/","name":"DeferredReturn","pl":"Java"},"frontmatter":{"shortDescription":"A return statement in the middle of a method doesn't return immediately"}}},{"node":{"slug":"misconceptions/Java/ElsIf/","fields":{"slug":"/misconceptions/Java/ElsIf/","name":"ElsIf","pl":"Java"},"frontmatter":{"shortDescription":"There is an elsif keyword for multi-way conditional statements"}}},{"node":{"slug":"misconceptions/Java/ElseAlwaysExecutes/","fields":{"slug":"/misconceptions/Java/ElseAlwaysExecutes/","name":"ElseAlwaysExecutes","pl":"Java"},"frontmatter":{"shortDescription":"The else branch of an if-else statement always executes"}}},{"node":{"slug":"misconceptions/Java/EqualityOperatorComparesObjectsValues/","fields":{"slug":"/misconceptions/Java/EqualityOperatorComparesObjectsValues/","name":"EqualityOperatorComparesObjectsValues","pl":"Java"},"frontmatter":{"shortDescription":"o==p compares the objects referred to by variables o and p"}}},{"node":{"slug":"misconceptions/Java/EqualsComparesReferences/","fields":{"slug":"/misconceptions/Java/EqualsComparesReferences/","name":"EqualsComparesReferences","pl":"Java"},"frontmatter":{"shortDescription":"o.equals(p) compares the references stored in the variables o and p"}}},{"node":{"slug":"misconceptions/Java/EvaluationResultsArePrinted/","fields":{"slug":"/misconceptions/Java/EvaluationResultsArePrinted/","name":"EvaluationResultsArePrinted","pl":"Java"},"frontmatter":{"shortDescription":"Evaluating an expression means outputting its result"}}},{"node":{"slug":"misconceptions/Java/ExceptionRoot/","fields":{"slug":"/misconceptions/Java/ExceptionRoot/","name":"ExceptionRoot","pl":"Java"},"frontmatter":{"shortDescription":"Exception is the top-most exception class"}}},{"node":{"slug":"misconceptions/Java/ExpressionAssigns/","fields":{"slug":"/misconceptions/Java/ExpressionAssigns/","name":"ExpressionAssigns","pl":"Java"},"frontmatter":{"shortDescription":"An expression that reads a variable also updates its value after the evaluation"}}},{"node":{"slug":"misconceptions/Java/ExpressionsDynamicallyTyped/","fields":{"slug":"/misconceptions/Java/ExpressionsDynamicallyTyped/","name":"ExpressionsDynamicallyTyped","pl":"Java"},"frontmatter":{"shortDescription":"One has to evaluate an expression to determine its type"}}},{"node":{"slug":"misconceptions/Java/FinalReferenceImpliesImmutability/","fields":{"slug":"/misconceptions/Java/FinalReferenceImpliesImmutability/","name":"FinalReferenceImpliesImmutability","pl":"Java"},"frontmatter":{"shortDescription":"An object referred to by a final variable is an immutable object"}}},{"node":{"slug":"misconceptions/Java/ForEachIteratesOverIndices/","fields":{"slug":"/misconceptions/Java/ForEachIteratesOverIndices/","name":"ForEachIteratesOverIndices","pl":"Java"},"frontmatter":{"shortDescription":"An enhanced for loop iterates over the indices of an array or a collection"}}},{"node":{"slug":"misconceptions/Java/ForEachTraversesRecursiveStructure/","fields":{"slug":"/misconceptions/Java/ForEachTraversesRecursiveStructure/","name":"ForEachTraversesRecursiveStructure","pl":"Java"},"frontmatter":{"shortDescription":"For-each loops know how to traverse any recursive data structure"}}},{"node":{"slug":"misconceptions/Java/ForEachVariableIsElement/","fields":{"slug":"/misconceptions/Java/ForEachVariableIsElement/","name":"ForEachVariableIsElement","pl":"Java"},"frontmatter":{"shortDescription":"One can assign to the variable of an enhanced for statement to store a value in the corresponding array or collection element"}}},{"node":{"slug":"misconceptions/Java/ForIsConditional/","fields":{"slug":"/misconceptions/Java/ForIsConditional/","name":"ForIsConditional","pl":"Java"},"frontmatter":{"shortDescription":"The body of a for statement executes at most once"}}},{"node":{"slug":"misconceptions/Java/ForVariableScopeBeyondLoop/","fields":{"slug":"/misconceptions/Java/ForVariableScopeBeyondLoop/","name":"ForVariableScopeBeyondLoop","pl":"Java"},"frontmatter":{"shortDescription":"The scope of variables declared in a for loop header extends beyond the loop"}}},{"node":{"slug":"misconceptions/Java/FrameIsClassInstance/","fields":{"slug":"/misconceptions/Java/FrameIsClassInstance/","name":"FrameIsClassInstance","pl":"Java"},"frontmatter":{"shortDescription":"A stack frame is the same as an instance of a class"}}},{"node":{"slug":"misconceptions/Java/IfIsLoop/","fields":{"slug":"/misconceptions/Java/IfIsLoop/","name":"IfIsLoop","pl":"Java"},"frontmatter":{"shortDescription":"The body of an if statement executes repeatedly, as long as the condition holds"}}},{"node":{"slug":"misconceptions/Java/IfRequiresElse/","fields":{"slug":"/misconceptions/Java/IfRequiresElse/","name":"IfRequiresElse","pl":"Java"},"frontmatter":{"shortDescription":"Every if statement requires an else"}}},{"node":{"slug":"misconceptions/Java/ImmutableRequiresFinalParameters/","fields":{"slug":"/misconceptions/Java/ImmutableRequiresFinalParameters/","name":"ImmutableRequiresFinalParameters","pl":"Java"},"frontmatter":{"shortDescription":"Immutable classes need final constructor/method parameters"}}},{"node":{"slug":"misconceptions/Java/ImplicitInterfaceImplementation/","fields":{"slug":"/misconceptions/Java/ImplicitInterfaceImplementation/","name":"ImplicitInterfaceImplementation","pl":"Java"},"frontmatter":{"shortDescription":"Java implicitly produces implementations of any methods a class inherits from the interfaces it implements"}}},{"node":{"slug":"misconceptions/Java/IntegerDivisionToRational/","fields":{"slug":"/misconceptions/Java/IntegerDivisionToRational/","name":"IntegerDivisionToRational","pl":"Java"},"frontmatter":{"shortDescription":"Dividing two integers can produce a rational number"}}},{"node":{"slug":"misconceptions/Java/InterfaceExtendClass/","fields":{"slug":"/misconceptions/Java/InterfaceExtendClass/","name":"InterfaceExtendClass","pl":"Java"},"frontmatter":{"shortDescription":"An interface can extend a class"}}},{"node":{"slug":"misconceptions/Java/LargeIntegerLong/","fields":{"slug":"/misconceptions/Java/LargeIntegerLong/","name":"LargeIntegerLong","pl":"Java"},"frontmatter":{"shortDescription":"Large integer numbers have type long"}}},{"node":{"slug":"misconceptions/Java/LiteralNoExpression/","fields":{"slug":"/misconceptions/Java/LiteralNoExpression/","name":"LiteralNoExpression","pl":"Java"},"frontmatter":{"shortDescription":"A literal is not an expression"}}},{"node":{"slug":"misconceptions/Java/LiteralString/","fields":{"slug":"/misconceptions/Java/LiteralString/","name":"LiteralString","pl":"Java"},"frontmatter":{"shortDescription":"When passing a literal string as argument to a method, no quotes are needed"}}},{"node":{"slug":"misconceptions/Java/LocalVariablesAutoInitialized/","fields":{"slug":"/misconceptions/Java/LocalVariablesAutoInitialized/","name":"LocalVariablesAutoInitialized","pl":"Java"},"frontmatter":{"shortDescription":"Local variables are automatically initialized"}}},{"node":{"slug":"misconceptions/Java/LoopBodyScopeImpliesLoopLifetime/","fields":{"slug":"/misconceptions/Java/LoopBodyScopeImpliesLoopLifetime/","name":"LoopBodyScopeImpliesLoopLifetime","pl":"Java"},"frontmatter":{"shortDescription":"Lifetime of variables declared in a loop body extends across all loop iterations"}}},{"node":{"slug":"misconceptions/Java/LoopTerminatingCondition/","fields":{"slug":"/misconceptions/Java/LoopTerminatingCondition/","name":"LoopTerminatingCondition","pl":"Java"},"frontmatter":{"shortDescription":"For and while loops end when the condition becomes true"}}},{"node":{"slug":"misconceptions/Java/MapToBooleanWithConditionalOperator/","fields":{"slug":"/misconceptions/Java/MapToBooleanWithConditionalOperator/","name":"MapToBooleanWithConditionalOperator","pl":"Java"},"frontmatter":{"shortDescription":"To map a boolean expression to a boolean, a conditional operator is necessary"}}},{"node":{"slug":"misconceptions/Java/MapToBooleanWithIf/","fields":{"slug":"/misconceptions/Java/MapToBooleanWithIf/","name":"MapToBooleanWithIf","pl":"Java"},"frontmatter":{"shortDescription":"To map a boolean expression to a boolean, an if statement is necessary"}}},{"node":{"slug":"misconceptions/Java/MethodAsField/","fields":{"slug":"/misconceptions/Java/MethodAsField/","name":"MethodAsField","pl":"Java"},"frontmatter":{"shortDescription":"Each object contains its own special fields for all of its methods"}}},{"node":{"slug":"misconceptions/Java/MethodWithoutReturnType/","fields":{"slug":"/misconceptions/Java/MethodWithoutReturnType/","name":"MethodWithoutReturnType","pl":"Java"},"frontmatter":{"shortDescription":"A method declaration does not need to include a return type"}}},{"node":{"slug":"misconceptions/Java/MethodsWithoutClass/","fields":{"slug":"/misconceptions/Java/MethodsWithoutClass/","name":"MethodsWithoutClass","pl":"Java"},"frontmatter":{"shortDescription":"Methods can be defined outside a class"}}},{"node":{"slug":"misconceptions/Java/MultiReferenceVariable/","fields":{"slug":"/misconceptions/Java/MultiReferenceVariable/","name":"MultiReferenceVariable","pl":"Java"},"frontmatter":{"shortDescription":"A reference variable can point to multiple objects"}}},{"node":{"slug":"misconceptions/Java/MultiValueVariable/","fields":{"slug":"/misconceptions/Java/MultiValueVariable/","name":"MultiValueVariable","pl":"Java"},"frontmatter":{"shortDescription":"A variable can contain more than one value"}}},{"node":{"slug":"misconceptions/Java/MultidimensionalArray/","fields":{"slug":"/misconceptions/Java/MultidimensionalArray/","name":"MultidimensionalArray","pl":"Java"},"frontmatter":{"shortDescription":"A multi-dimensional array is one single array object"}}},{"node":{"slug":"misconceptions/Java/MultipleSuperclasses/","fields":{"slug":"/misconceptions/Java/MultipleSuperclasses/","name":"MultipleSuperclasses","pl":"Java"},"frontmatter":{"shortDescription":"A class can have multiple superclasses"}}},{"node":{"slug":"misconceptions/Java/MustInitializeFieldInConstructor/","fields":{"slug":"/misconceptions/Java/MustInitializeFieldInConstructor/","name":"MustInitializeFieldInConstructor","pl":"Java"},"frontmatter":{"shortDescription":"Constructors must assign values to all fields"}}},{"node":{"slug":"misconceptions/Java/NamedTypeParameter/","fields":{"slug":"/misconceptions/Java/NamedTypeParameter/","name":"NamedTypeParameter","pl":"Java"},"frontmatter":{"shortDescription":"To instantiate a generic type, for each type parameter one has to specify both the name and the type"}}},{"node":{"slug":"misconceptions/Java/NestedObjectsImplyNestedClasses/","fields":{"slug":"/misconceptions/Java/NestedObjectsImplyNestedClasses/","name":"NestedObjectsImplyNestedClasses","pl":"Java"},"frontmatter":{"shortDescription":"If objects are part of a containment hierarchy, their classes are nested, too"}}},{"node":{"slug":"misconceptions/Java/NestedPackages/","fields":{"slug":"/misconceptions/Java/NestedPackages/","name":"NestedPackages","pl":"Java"},"frontmatter":{"shortDescription":"Packages can contain other packages which have access to members of the containing package"}}},{"node":{"slug":"misconceptions/Java/NoAtomicExpression/","fields":{"slug":"/misconceptions/Java/NoAtomicExpression/","name":"NoAtomicExpression","pl":"Java"},"frontmatter":{"shortDescription":"Expressions must consist of more than one piece"}}},{"node":{"slug":"misconceptions/Java/NoCallOnStringLiteral/","fields":{"slug":"/misconceptions/Java/NoCallOnStringLiteral/","name":"NoCallOnStringLiteral","pl":"Java"},"frontmatter":{"shortDescription":"One cannot invoke methods on String literals"}}},{"node":{"slug":"misconceptions/Java/NoCastIfSameSize/","fields":{"slug":"/misconceptions/Java/NoCastIfSameSize/","name":"NoCastIfSameSize","pl":"Java"},"frontmatter":{"shortDescription":"If a variable is at least as big (bit-width) as a value, then no cast is needed to a assign the value to the variable"}}},{"node":{"slug":"misconceptions/Java/NoCharEscape/","fields":{"slug":"/misconceptions/Java/NoCharEscape/","name":"NoCharEscape","pl":"Java"},"frontmatter":{"shortDescription":"\\ is a normal character in char and String literals"}}},{"node":{"slug":"misconceptions/Java/NoEmptyConstructor/","fields":{"slug":"/misconceptions/Java/NoEmptyConstructor/","name":"NoEmptyConstructor","pl":"Java"},"frontmatter":{"shortDescription":"A constructor must do something"}}},{"node":{"slug":"misconceptions/Java/NoFieldInheritance/","fields":{"slug":"/misconceptions/Java/NoFieldInheritance/","name":"NoFieldInheritance","pl":"Java"},"frontmatter":{"shortDescription":"An object contains only the fields declared in its class"}}},{"node":{"slug":"misconceptions/Java/NoFieldlessObjects/","fields":{"slug":"/misconceptions/Java/NoFieldlessObjects/","name":"NoFieldlessObjects","pl":"Java"},"frontmatter":{"shortDescription":"Objects without instance variables can't exist"}}},{"node":{"slug":"misconceptions/Java/NoFloatLiterals/","fields":{"slug":"/misconceptions/Java/NoFloatLiterals/","name":"NoFloatLiterals","pl":"Java"},"frontmatter":{"shortDescription":"There are no float literals"}}},{"node":{"slug":"misconceptions/Java/NoImplicitWidening/","fields":{"slug":"/misconceptions/Java/NoImplicitWidening/","name":"NoImplicitWidening","pl":"Java"},"frontmatter":{"shortDescription":"Smaller types are never automatically converted into bigger ones without an explicit cast"}}},{"node":{"slug":"misconceptions/Java/NoInsideMethodCallInConstructor/","fields":{"slug":"/misconceptions/Java/NoInsideMethodCallInConstructor/","name":"NoInsideMethodCallInConstructor","pl":"Java"},"frontmatter":{"shortDescription":"It is foirbidden to call other methods on the same object while inside its constructor"}}},{"node":{"slug":"misconceptions/Java/NoJaggedArrays/","fields":{"slug":"/misconceptions/Java/NoJaggedArrays/","name":"NoJaggedArrays","pl":"Java"},"frontmatter":{"shortDescription":"Multi-dimensional arrays have a rectangular shape"}}},{"node":{"slug":"misconceptions/Java/NoLocalVariables/","fields":{"slug":"/misconceptions/Java/NoLocalVariables/","name":"NoLocalVariables","pl":"Java"},"frontmatter":{"shortDescription":"There are no local variables"}}},{"node":{"slug":"misconceptions/Java/NoLongLiterals/","fields":{"slug":"/misconceptions/Java/NoLongLiterals/","name":"NoLongLiterals","pl":"Java"},"frontmatter":{"shortDescription":"There are no long literals"}}},{"node":{"slug":"misconceptions/Java/NoMethodInheritance/","fields":{"slug":"/misconceptions/Java/NoMethodInheritance/","name":"NoMethodInheritance","pl":"Java"},"frontmatter":{"shortDescription":"Subclasses inherit fields but not methods"}}},{"node":{"slug":"misconceptions/Java/NoReservedWords/","fields":{"slug":"/misconceptions/Java/NoReservedWords/","name":"NoReservedWords","pl":"Java"},"frontmatter":{"shortDescription":"Every sequence of letters and digits starting with a letter can be used as an identifier"}}},{"node":{"slug":"misconceptions/Java/NoShortCircuit/","fields":{"slug":"/misconceptions/Java/NoShortCircuit/","name":"NoShortCircuit","pl":"Java"},"frontmatter":{"shortDescription":"&& and || always evaluate both operands"}}},{"node":{"slug":"misconceptions/Java/NoSingleLogicAnd/","fields":{"slug":"/misconceptions/Java/NoSingleLogicAnd/","name":"NoSingleLogicAnd","pl":"Java"},"frontmatter":{"shortDescription":"& is only a bitwise AND"}}},{"node":{"slug":"misconceptions/Java/NoStringToString/","fields":{"slug":"/misconceptions/Java/NoStringToString/","name":"NoStringToString","pl":"Java"},"frontmatter":{"shortDescription":"One cannot invoke toString() on a String"}}},{"node":{"slug":"misconceptions/Java/NullIsObject/","fields":{"slug":"/misconceptions/Java/NullIsObject/","name":"NullIsObject","pl":"Java"},"frontmatter":{"shortDescription":"null is an object"}}},{"node":{"slug":"misconceptions/Java/NullPointerExceptionCompileTime/","fields":{"slug":"/misconceptions/Java/NullPointerExceptionCompileTime/","name":"NullPointerExceptionCompileTime","pl":"Java"},"frontmatter":{"shortDescription":"NullPointerExceptions are detected at compile time"}}},{"node":{"slug":"misconceptions/Java/NumericToBooleanCoercion/","fields":{"slug":"/misconceptions/Java/NumericToBooleanCoercion/","name":"NumericToBooleanCoercion","pl":"Java"},"frontmatter":{"shortDescription":"Numeric types can be coerced to boolean"}}},{"node":{"slug":"misconceptions/Java/ObjectsMustBeNamed/","fields":{"slug":"/misconceptions/Java/ObjectsMustBeNamed/","name":"ObjectsMustBeNamed","pl":"Java"},"frontmatter":{"shortDescription":"A variable is needed to instantiate an object"}}},{"node":{"slug":"misconceptions/Java/OnlyInnermostArrayElements/","fields":{"slug":"/misconceptions/Java/OnlyInnermostArrayElements/","name":"OnlyInnermostArrayElements","pl":"Java"},"frontmatter":{"shortDescription":"Only the elements of the innermost array of a multi-dimensional array are accessible"}}},{"node":{"slug":"misconceptions/Java/OutOfBoundsElementsAreNull/","fields":{"slug":"/misconceptions/Java/OutOfBoundsElementsAreNull/","name":"OutOfBoundsElementsAreNull","pl":"Java"},"frontmatter":{"shortDescription":"Out-of-bounds array elements are null"}}},{"node":{"slug":"misconceptions/Java/OutsideInMethodNesting/","fields":{"slug":"/misconceptions/Java/OutsideInMethodNesting/","name":"OutsideInMethodNesting","pl":"Java"},"frontmatter":{"shortDescription":"Nested method calls are invoked outside in"}}},{"node":{"slug":"misconceptions/Java/ParenthesesOnlyIfArgument/","fields":{"slug":"/misconceptions/Java/ParenthesesOnlyIfArgument/","name":"ParenthesesOnlyIfArgument","pl":"Java"},"frontmatter":{"shortDescription":"() are optional for method calls without arguments"}}},{"node":{"slug":"misconceptions/Java/PreIncrementBeforeLoop/","fields":{"slug":"/misconceptions/Java/PreIncrementBeforeLoop/","name":"PreIncrementBeforeLoop","pl":"Java"},"frontmatter":{"shortDescription":"Pre-increment in update part of for loop means increment before loop body"}}},{"node":{"slug":"misconceptions/Java/PrimitiveIsObject/","fields":{"slug":"/misconceptions/Java/PrimitiveIsObject/","name":"PrimitiveIsObject","pl":"Java"},"frontmatter":{"shortDescription":"Primitive values are heap objects"}}},{"node":{"slug":"misconceptions/Java/PrimitiveTypeParameter/","fields":{"slug":"/misconceptions/Java/PrimitiveTypeParameter/","name":"PrimitiveTypeParameter","pl":"Java"},"frontmatter":{"shortDescription":"Type parameters of generic types can be instantiated with primitive types"}}},{"node":{"slug":"misconceptions/Java/PrimitiveVariablesDynamicallyTyped/","fields":{"slug":"/misconceptions/Java/PrimitiveVariablesDynamicallyTyped/","name":"PrimitiveVariablesDynamicallyTyped","pl":"Java"},"frontmatter":{"shortDescription":"The type of a primitive variable depends on its value"}}},{"node":{"slug":"misconceptions/Java/PrivateAccessibleInSubclass/","fields":{"slug":"/misconceptions/Java/PrivateAccessibleInSubclass/","name":"PrivateAccessibleInSubclass","pl":"Java"},"frontmatter":{"shortDescription":"Private members of a superclass are accessible from a subclass"}}},{"node":{"slug":"misconceptions/Java/PrivateFieldsImplyImmutability/","fields":{"slug":"/misconceptions/Java/PrivateFieldsImplyImmutability/","name":"PrivateFieldsImplyImmutability","pl":"Java"},"frontmatter":{"shortDescription":"A class where all fields are private is immutable"}}},{"node":{"slug":"misconceptions/Java/PrivateFromOtherInstance/","fields":{"slug":"/misconceptions/Java/PrivateFromOtherInstance/","name":"PrivateFromOtherInstance","pl":"Java"},"frontmatter":{"shortDescription":"An object cannot access private members of other objects of the same class"}}},{"node":{"slug":"misconceptions/Java/PrivateFromStatic/","fields":{"slug":"/misconceptions/Java/PrivateFromStatic/","name":"PrivateFromStatic","pl":"Java"},"frontmatter":{"shortDescription":"Static methods cannot access private members of instances of same class"}}},{"node":{"slug":"misconceptions/Java/PrivateMeansFinal/","fields":{"slug":"/misconceptions/Java/PrivateMeansFinal/","name":"PrivateMeansFinal","pl":"Java"},"frontmatter":{"shortDescription":"A private field cannot be changed"}}},{"node":{"slug":"misconceptions/Java/RationalLiterals/","fields":{"slug":"/misconceptions/Java/RationalLiterals/","name":"RationalLiterals","pl":"Java"},"frontmatter":{"shortDescription":"Rational fractions are literals"}}},{"node":{"slug":"misconceptions/Java/RecursiveActivationsShareFrame/","fields":{"slug":"/misconceptions/Java/RecursiveActivationsShareFrame/","name":"RecursiveActivationsShareFrame","pl":"Java"},"frontmatter":{"shortDescription":"Recursive calls of a method share a stack frame"}}},{"node":{"slug":"misconceptions/Java/RecursiveCallSiteNoReturn/","fields":{"slug":"/misconceptions/Java/RecursiveCallSiteNoReturn/","name":"RecursiveCallSiteNoReturn","pl":"Java"},"frontmatter":{"shortDescription":"Tail-recursive call sites of non-void methods need no return statement"}}},{"node":{"slug":"misconceptions/Java/RecursiveMethodImpliesRecursiveType/","fields":{"slug":"/misconceptions/Java/RecursiveMethodImpliesRecursiveType/","name":"RecursiveMethodImpliesRecursiveType","pl":"Java"},"frontmatter":{"shortDescription":"A class with a recursive method represents part of a recursive data structure"}}},{"node":{"slug":"misconceptions/Java/RecursiveMethodNeedsIfElse/","fields":{"slug":"/misconceptions/Java/RecursiveMethodNeedsIfElse/","name":"RecursiveMethodNeedsIfElse","pl":"Java"},"frontmatter":{"shortDescription":"A recursive method needs to contain an if-else statement"}}},{"node":{"slug":"misconceptions/Java/ReferenceIntoStack/","fields":{"slug":"/misconceptions/Java/ReferenceIntoStack/","name":"ReferenceIntoStack","pl":"Java"},"frontmatter":{"shortDescription":"References can point into the stack"}}},{"node":{"slug":"misconceptions/Java/ReferenceToBooleanCoercion/","fields":{"slug":"/misconceptions/Java/ReferenceToBooleanCoercion/","name":"ReferenceToBooleanCoercion","pl":"Java"},"frontmatter":{"shortDescription":"Every reference type can be coerced to boolean"}}},{"node":{"slug":"misconceptions/Java/ReferenceToIntegerConversion/","fields":{"slug":"/misconceptions/Java/ReferenceToIntegerConversion/","name":"ReferenceToIntegerConversion","pl":"Java"},"frontmatter":{"shortDescription":"One can cast between references and ints"}}},{"node":{"slug":"misconceptions/Java/ReferenceToVariable/","fields":{"slug":"/misconceptions/Java/ReferenceToVariable/","name":"ReferenceToVariable","pl":"Java"},"frontmatter":{"shortDescription":"References can point to variables"}}},{"node":{"slug":"misconceptions/Java/ReferringToRecursiveStructureMakesRecursive/","fields":{"slug":"/misconceptions/Java/ReferringToRecursiveStructureMakesRecursive/","name":"ReferringToRecursiveStructureMakesRecursive","pl":"Java"},"frontmatter":{"shortDescription":"A class referring to a recursive data structure is (indirectly) part of that recursion as well"}}},{"node":{"slug":"misconceptions/Java/ReturnCall/","fields":{"slug":"/misconceptions/Java/ReturnCall/","name":"ReturnCall","pl":"Java"},"frontmatter":{"shortDescription":"Return statements need () around the return value"}}},{"node":{"slug":"misconceptions/Java/ReturnUnwindsMultipleFrames/","fields":{"slug":"/misconceptions/Java/ReturnUnwindsMultipleFrames/","name":"ReturnUnwindsMultipleFrames","pl":"Java"},"frontmatter":{"shortDescription":"A return statement can unwind multiple call stack frames"}}},{"node":{"slug":"misconceptions/Java/RightToLeftChaining/","fields":{"slug":"/misconceptions/Java/RightToLeftChaining/","name":"RightToLeftChaining","pl":"Java"},"frontmatter":{"shortDescription":"Chained accesses are invoked from right to left"}}},{"node":{"slug":"misconceptions/Java/RuntimeExceptionChecked/","fields":{"slug":"/misconceptions/Java/RuntimeExceptionChecked/","name":"RuntimeExceptionChecked","pl":"Java"},"frontmatter":{"shortDescription":"RuntimeExceptions are checked exceptions"}}},{"node":{"slug":"misconceptions/Java/SingleQuoteString/","fields":{"slug":"/misconceptions/Java/SingleQuoteString/","name":"SingleQuoteString","pl":"Java"},"frontmatter":{"shortDescription":"String literals can be in single quotes"}}},{"node":{"slug":"misconceptions/Java/StackTraceIsCallHistory/","fields":{"slug":"/misconceptions/Java/StackTraceIsCallHistory/","name":"StackTraceIsCallHistory","pl":"Java"},"frontmatter":{"shortDescription":"A stack trace is the sequence of previously called methods"}}},{"node":{"slug":"misconceptions/Java/StaticCallPolymorphic/","fields":{"slug":"/misconceptions/Java/StaticCallPolymorphic/","name":"StaticCallPolymorphic","pl":"Java"},"frontmatter":{"shortDescription":"A static method call is dispatched polymorphically at runtime based on the argument types"}}},{"node":{"slug":"misconceptions/Java/StaticDispatch/","fields":{"slug":"/misconceptions/Java/StaticDispatch/","name":"StaticDispatch","pl":"Java"},"frontmatter":{"shortDescription":"The method to be called is determined by the static type"}}},{"node":{"slug":"misconceptions/Java/StringLengthField/","fields":{"slug":"/misconceptions/Java/StringLengthField/","name":"StringLengthField","pl":"Java"},"frontmatter":{"shortDescription":"One can know the length of a String object by accessing its length field"}}},{"node":{"slug":"misconceptions/Java/StringLiteralNoObject/","fields":{"slug":"/misconceptions/Java/StringLiteralNoObject/","name":"StringLiteralNoObject","pl":"Java"},"frontmatter":{"shortDescription":"One needs to call the String constructor to get a String object from a literal"}}},{"node":{"slug":"misconceptions/Java/StringPlusStringifiesExpression/","fields":{"slug":"/misconceptions/Java/StringPlusStringifiesExpression/","name":"StringPlusStringifiesExpression","pl":"Java"},"frontmatter":{"shortDescription":"String concatenation stringifies non-String operand expressions"}}},{"node":{"slug":"misconceptions/Java/StringRepetitionOperator/","fields":{"slug":"/misconceptions/Java/StringRepetitionOperator/","name":"StringRepetitionOperator","pl":"Java"},"frontmatter":{"shortDescription":"The multiplication operator can repeat a String a number of times"}}},{"node":{"slug":"misconceptions/Java/SubtypeCompatibleWithSupertype/","fields":{"slug":"/misconceptions/Java/SubtypeCompatibleWithSupertype/","name":"SubtypeCompatibleWithSupertype","pl":"Java"},"frontmatter":{"shortDescription":"A variable of a subtype can reference an object of a supertype"}}},{"node":{"slug":"misconceptions/Java/SuperAlwaysHasParentheses/","fields":{"slug":"/misconceptions/Java/SuperAlwaysHasParentheses/","name":"SuperAlwaysHasParentheses","pl":"Java"},"frontmatter":{"shortDescription":"To call a method on a superclass, parentheses are needed after the keyword super"}}},{"node":{"slug":"misconceptions/Java/SuperNotFirstStatement/","fields":{"slug":"/misconceptions/Java/SuperNotFirstStatement/","name":"SuperNotFirstStatement","pl":"Java"},"frontmatter":{"shortDescription":"super() can be called anywhere in the constructor of a subclass"}}},{"node":{"slug":"misconceptions/Java/SuperclassObjectAllocated/","fields":{"slug":"/misconceptions/Java/SuperclassObjectAllocated/","name":"SuperclassObjectAllocated","pl":"Java"},"frontmatter":{"shortDescription":"When instantiating an object of a subclass, an object of a superclass is also allocated"}}},{"node":{"slug":"misconceptions/Java/SupertypeIncompatibleWithSubtype/","fields":{"slug":"/misconceptions/Java/SupertypeIncompatibleWithSubtype/","name":"SupertypeIncompatibleWithSubtype","pl":"Java"},"frontmatter":{"shortDescription":"A variable of a supertype cannot reference an object of a subtype"}}},{"node":{"slug":"misconceptions/Java/TargetTyping/","fields":{"slug":"/misconceptions/Java/TargetTyping/","name":"TargetTyping","pl":"Java"},"frontmatter":{"shortDescription":"The type of a numerical expression depends on the type expected by the surrounding context"}}},{"node":{"slug":"misconceptions/Java/ThisAsField/","fields":{"slug":"/misconceptions/Java/ThisAsField/","name":"ThisAsField","pl":"Java"},"frontmatter":{"shortDescription":"this is a special field in the object"}}},{"node":{"slug":"misconceptions/Java/ThisAssignable/","fields":{"slug":"/misconceptions/Java/ThisAssignable/","name":"ThisAssignable","pl":"Java"},"frontmatter":{"shortDescription":"One can assign to this"}}},{"node":{"slug":"misconceptions/Java/ThisCanBeNull/","fields":{"slug":"/misconceptions/Java/ThisCanBeNull/","name":"ThisCanBeNull","pl":"Java"},"frontmatter":{"shortDescription":"this can be null"}}},{"node":{"slug":"misconceptions/Java/ThisExistsInStaticMethod/","fields":{"slug":"/misconceptions/Java/ThisExistsInStaticMethod/","name":"ThisExistsInStaticMethod","pl":"Java"},"frontmatter":{"shortDescription":"this is a local variable, also in static methods"}}},{"node":{"slug":"misconceptions/Java/ThisInConstructorIsNull/","fields":{"slug":"/misconceptions/Java/ThisInConstructorIsNull/","name":"ThisInConstructorIsNull","pl":"Java"},"frontmatter":{"shortDescription":"In a constructor, this is null"}}},{"node":{"slug":"misconceptions/Java/ThisNoExpression/","fields":{"slug":"/misconceptions/Java/ThisNoExpression/","name":"ThisNoExpression","pl":"Java"},"frontmatter":{"shortDescription":"The name this is not an expression"}}},{"node":{"slug":"misconceptions/Java/ToStringPrints/","fields":{"slug":"/misconceptions/Java/ToStringPrints/","name":"ToStringPrints","pl":"Java"},"frontmatter":{"shortDescription":"Invoking toString() prints something"}}},{"node":{"slug":"misconceptions/Java/TryCatchMandatory/","fields":{"slug":"/misconceptions/Java/TryCatchMandatory/","name":"TryCatchMandatory","pl":"Java"},"frontmatter":{"shortDescription":"When a piece of code can throw an exception, it must be surrounded with a try/catch block"}}},{"node":{"slug":"misconceptions/Java/TryFinishes/","fields":{"slug":"/misconceptions/Java/TryFinishes/","name":"TryFinishes","pl":"Java"},"frontmatter":{"shortDescription":"Exceptions get thrown at the end of the try block"}}},{"node":{"slug":"misconceptions/Java/UndeclaredVariables/","fields":{"slug":"/misconceptions/Java/UndeclaredVariables/","name":"UndeclaredVariables","pl":"Java"},"frontmatter":{"shortDescription":"Variables can be used even without being declared beforehand"}}},{"node":{"slug":"misconceptions/Java/UnqualifiedNamesMustDiffer/","fields":{"slug":"/misconceptions/Java/UnqualifiedNamesMustDiffer/","name":"UnqualifiedNamesMustDiffer","pl":"Java"},"frontmatter":{"shortDescription":"The unqualified names of different classes must be different"}}},{"node":{"slug":"misconceptions/Java/UntypedVariables/","fields":{"slug":"/misconceptions/Java/UntypedVariables/","name":"UntypedVariables","pl":"Java"},"frontmatter":{"shortDescription":"Variable declarations don't need a type"}}},{"node":{"slug":"misconceptions/Java/UseOfSelfTypeImpliesRecursiveType/","fields":{"slug":"/misconceptions/Java/UseOfSelfTypeImpliesRecursiveType/","name":"UseOfSelfTypeImpliesRecursiveType","pl":"Java"},"frontmatter":{"shortDescription":"If a class has a method that has a local variable, parameter, or return value with the class as its type, the class is a recursive type"}}},{"node":{"slug":"misconceptions/Java/VariablesHoldExpressions/","fields":{"slug":"/misconceptions/Java/VariablesHoldExpressions/","name":"VariablesHoldExpressions","pl":"Java"},"frontmatter":{"shortDescription":"= stores an expression in a variable"}}},{"node":{"slug":"misconceptions/Java/VariablesHoldObjects/","fields":{"slug":"/misconceptions/Java/VariablesHoldObjects/","name":"VariablesHoldObjects","pl":"Java"},"frontmatter":{"shortDescription":"A variable of a reference type contains a whole object"}}},{"node":{"slug":"misconceptions/Java/VoidMethodNotRecursive/","fields":{"slug":"/misconceptions/Java/VoidMethodNotRecursive/","name":"VoidMethodNotRecursive","pl":"Java"},"frontmatter":{"shortDescription":"A method with void return type can't be recursive"}}},{"node":{"slug":"misconceptions/Java/VoidMethodReturnsValue/","fields":{"slug":"/misconceptions/Java/VoidMethodReturnsValue/","name":"VoidMethodReturnsValue","pl":"Java"},"frontmatter":{"shortDescription":"A method with void return type can return a value"}}},{"node":{"slug":"misconceptions/Java/ZeroDigitsCompress/","fields":{"slug":"/misconceptions/Java/ZeroDigitsCompress/","name":"ZeroDigitsCompress","pl":"Java"},"frontmatter":{"shortDescription":"In integer numbers, decimal digits with value `0` take less storage than decimal digits with other values"}}},{"node":{"slug":"misconceptions/JavaScript/AccessingInexistentPropertyError/","fields":{"slug":"/misconceptions/JavaScript/AccessingInexistentPropertyError/","name":"AccessingInexistentPropertyError","pl":"JavaScript"},"frontmatter":{"shortDescription":"Accessing a non existent property on an object produces an error"}}},{"node":{"slug":"misconceptions/JavaScript/ArrowFunctionNoImpliedReturn/","fields":{"slug":"/misconceptions/JavaScript/ArrowFunctionNoImpliedReturn/","name":"ArrowFunctionNoImpliedReturn","pl":"JavaScript"},"frontmatter":{"shortDescription":"Even when an arrow function consists just of an expression, the return keyword must be explicitly written"}}},{"node":{"slug":"misconceptions/JavaScript/ArrowFunctionRequiresFunctionKeyword/","fields":{"slug":"/misconceptions/JavaScript/ArrowFunctionRequiresFunctionKeyword/","name":"ArrowFunctionRequiresFunctionKeyword","pl":"JavaScript"},"frontmatter":{"shortDescription":"Arrow functions also require the keyword 'function'"}}},{"node":{"slug":"misconceptions/JavaScript/AssignmentCopiesObject/","fields":{"slug":"/misconceptions/JavaScript/AssignmentCopiesObject/","name":"AssignmentCopiesObject","pl":"JavaScript"},"frontmatter":{"shortDescription":"Assignment copies the object"}}},{"node":{"slug":"misconceptions/JavaScript/CallbackParametersInCaller/","fields":{"slug":"/misconceptions/JavaScript/CallbackParametersInCaller/","name":"CallbackParametersInCaller","pl":"JavaScript"},"frontmatter":{"shortDescription":"Parameters of a callback function may be written as parameters of the caller function"}}},{"node":{"slug":"misconceptions/JavaScript/CharType/","fields":{"slug":"/misconceptions/JavaScript/CharType/","name":"CharType","pl":"JavaScript"},"frontmatter":{"shortDescription":"A single character is of type char"}}},{"node":{"slug":"misconceptions/JavaScript/ClassDefinesType/","fields":{"slug":"/misconceptions/JavaScript/ClassDefinesType/","name":"ClassDefinesType","pl":"JavaScript"},"frontmatter":{"shortDescription":"The type of an object is equivalent to the type defined by its class definition"}}},{"node":{"slug":"misconceptions/JavaScript/ConditionalOperatorNotExpression/","fields":{"slug":"/misconceptions/JavaScript/ConditionalOperatorNotExpression/","name":"ConditionalOperatorNotExpression","pl":"JavaScript"},"frontmatter":{"shortDescription":"The conditional operator is not an expression"}}},{"node":{"slug":"misconceptions/JavaScript/ConstDeclarationCanBeLeftUninitialized/","fields":{"slug":"/misconceptions/JavaScript/ConstDeclarationCanBeLeftUninitialized/","name":"ConstDeclarationCanBeLeftUninitialized","pl":"JavaScript"},"frontmatter":{"shortDescription":"Declarations of constants do not need to be immediately initialized"}}},{"node":{"slug":"misconceptions/JavaScript/ConstReferenceImpliesImmutability/","fields":{"slug":"/misconceptions/JavaScript/ConstReferenceImpliesImmutability/","name":"ConstReferenceImpliesImmutability","pl":"JavaScript"},"frontmatter":{"shortDescription":"An object referred to by a const variable is an immutable object"}}},{"node":{"slug":"misconceptions/JavaScript/EqualityOperatorComparesObjectsValues/","fields":{"slug":"/misconceptions/JavaScript/EqualityOperatorComparesObjectsValues/","name":"EqualityOperatorComparesObjectsValues","pl":"JavaScript"},"frontmatter":{"shortDescription":"The equality operator compares two objects' values"}}},{"node":{"slug":"misconceptions/JavaScript/EqualityOperatorComparesOnlyTypes/","fields":{"slug":"/misconceptions/JavaScript/EqualityOperatorComparesOnlyTypes/","name":"EqualityOperatorComparesOnlyTypes","pl":"JavaScript"},"frontmatter":{"shortDescription":"The equality operator '==' compares only the types of the operands"}}},{"node":{"slug":"misconceptions/JavaScript/FunctionAsValueWithParentheses/","fields":{"slug":"/misconceptions/JavaScript/FunctionAsValueWithParentheses/","name":"FunctionAsValueWithParentheses","pl":"JavaScript"},"frontmatter":{"shortDescription":"To use a function as a value, one needs to have parentheses after its name"}}},{"node":{"slug":"misconceptions/JavaScript/FunctionOverloading/","fields":{"slug":"/misconceptions/JavaScript/FunctionOverloading/","name":"FunctionOverloading","pl":"JavaScript"},"frontmatter":{"shortDescription":"It is possible to create multiple functions with the same name but with different signatures"}}},{"node":{"slug":"misconceptions/JavaScript/FunctionsCannotBeImmediatelyInvoked/","fields":{"slug":"/misconceptions/JavaScript/FunctionsCannotBeImmediatelyInvoked/","name":"FunctionsCannotBeImmediatelyInvoked","pl":"JavaScript"},"frontmatter":{"shortDescription":"Functions cannot be called in the expression in which they are defined"}}},{"node":{"slug":"misconceptions/JavaScript/FunctionsMustBeNamed/","fields":{"slug":"/misconceptions/JavaScript/FunctionsMustBeNamed/","name":"FunctionsMustBeNamed","pl":"JavaScript"},"frontmatter":{"shortDescription":"Every function definition requires an associated name"}}},{"node":{"slug":"misconceptions/JavaScript/IdentifierAsStringInBracketNotation/","fields":{"slug":"/misconceptions/JavaScript/IdentifierAsStringInBracketNotation/","name":"IdentifierAsStringInBracketNotation","pl":"JavaScript"},"frontmatter":{"shortDescription":"An identifier used to access a property with the bracket notation is treated as a string"}}},{"node":{"slug":"misconceptions/JavaScript/MandatoryAssignment/","fields":{"slug":"/misconceptions/JavaScript/MandatoryAssignment/","name":"MandatoryAssignment","pl":"JavaScript"},"frontmatter":{"shortDescription":"An expression must be assigned to have a valid statement"}}},{"node":{"slug":"misconceptions/JavaScript/MapInPlace/","fields":{"slug":"/misconceptions/JavaScript/MapInPlace/","name":"MapInPlace","pl":"JavaScript"},"frontmatter":{"shortDescription":"Map modifies the elements of the array on which it operates in place"}}},{"node":{"slug":"misconceptions/JavaScript/NoAtomicExpression/","fields":{"slug":"/misconceptions/JavaScript/NoAtomicExpression/","name":"NoAtomicExpression","pl":"JavaScript"},"frontmatter":{"shortDescription":"Expressions must consist of more than one piece"}}},{"node":{"slug":"misconceptions/JavaScript/NoBracketNotationForObjects/","fields":{"slug":"/misconceptions/JavaScript/NoBracketNotationForObjects/","name":"NoBracketNotationForObjects","pl":"JavaScript"},"frontmatter":{"shortDescription":"Square brackets cannot be used to access properties of an object"}}},{"node":{"slug":"misconceptions/JavaScript/NoFunctionCallsChaining/","fields":{"slug":"/misconceptions/JavaScript/NoFunctionCallsChaining/","name":"NoFunctionCallsChaining","pl":"JavaScript"},"frontmatter":{"shortDescription":"It is not allowed to chain function calls"}}},{"node":{"slug":"misconceptions/JavaScript/NoGlobalObject/","fields":{"slug":"/misconceptions/JavaScript/NoGlobalObject/","name":"NoGlobalObject","pl":"JavaScript"},"frontmatter":{"shortDescription":"There isn't a global object"}}},{"node":{"slug":"misconceptions/JavaScript/NoReturnValue/","fields":{"slug":"/misconceptions/JavaScript/NoReturnValue/","name":"NoReturnValue","pl":"JavaScript"},"frontmatter":{"shortDescription":"Functions without return statements return no value at all"}}},{"node":{"slug":"misconceptions/JavaScript/NullAndUndefinedAreTheSame/","fields":{"slug":"/misconceptions/JavaScript/NullAndUndefinedAreTheSame/","name":"NullAndUndefinedAreTheSame","pl":"JavaScript"},"frontmatter":{"shortDescription":"The values null and undefined are the same"}}},{"node":{"slug":"misconceptions/JavaScript/NullIsObject/","fields":{"slug":"/misconceptions/JavaScript/NullIsObject/","name":"NullIsObject","pl":"JavaScript"},"frontmatter":{"shortDescription":"null is an object"}}},{"node":{"slug":"misconceptions/JavaScript/NumberOfParametersMatchArguments/","fields":{"slug":"/misconceptions/JavaScript/NumberOfParametersMatchArguments/","name":"NumberOfParametersMatchArguments","pl":"JavaScript"},"frontmatter":{"shortDescription":"Functions must be called with the same number of arguments as defined in their signature"}}},{"node":{"slug":"misconceptions/JavaScript/ObjectAsParameterIsCopied/","fields":{"slug":"/misconceptions/JavaScript/ObjectAsParameterIsCopied/","name":"ObjectAsParameterIsCopied","pl":"JavaScript"},"frontmatter":{"shortDescription":"Objects are passed by value"}}},{"node":{"slug":"misconceptions/JavaScript/PrototypesAreClasses/","fields":{"slug":"/misconceptions/JavaScript/PrototypesAreClasses/","name":"PrototypesAreClasses","pl":"JavaScript"},"frontmatter":{"shortDescription":"JavaScript is based on a class-based object model"}}},{"node":{"slug":"misconceptions/JavaScript/StringRepetitionOperator/","fields":{"slug":"/misconceptions/JavaScript/StringRepetitionOperator/","name":"StringRepetitionOperator","pl":"JavaScript"},"frontmatter":{"shortDescription":"One can repeat a String by multiplying it with a number"}}},{"node":{"slug":"misconceptions/JavaScript/ThisAssignable/","fields":{"slug":"/misconceptions/JavaScript/ThisAssignable/","name":"ThisAssignable","pl":"JavaScript"},"frontmatter":{"shortDescription":"One can assign to this"}}},{"node":{"slug":"misconceptions/JavaScript/TypeofArrayIsArray/","fields":{"slug":"/misconceptions/JavaScript/TypeofArrayIsArray/","name":"TypeofArrayIsArray","pl":"JavaScript"},"frontmatter":{"shortDescription":"The typeof operator applied on an array returns 'array'"}}},{"node":{"slug":"misconceptions/JavaScript/TypeofNullIsNull/","fields":{"slug":"/misconceptions/JavaScript/TypeofNullIsNull/","name":"TypeofNullIsNull","pl":"JavaScript"},"frontmatter":{"shortDescription":"The value null is of type 'null'"}}},{"node":{"slug":"misconceptions/Python/AssignCompares/","fields":{"slug":"/misconceptions/Python/AssignCompares/","name":"AssignCompares","pl":"Python"},"frontmatter":{"shortDescription":"= compares two values"}}},{"node":{"slug":"misconceptions/Python/AssignmentCopiesObject/","fields":{"slug":"/misconceptions/Python/AssignmentCopiesObject/","name":"AssignmentCopiesObject","pl":"Python"},"frontmatter":{"shortDescription":"Assignment copies the object"}}},{"node":{"slug":"misconceptions/Python/CannotChainAttributeAccesses/","fields":{"slug":"/misconceptions/Python/CannotChainAttributeAccesses/","name":"CannotChainAttributeAccesses","pl":"Python"},"frontmatter":{"shortDescription":"Attribute accesses cannot be chained together"}}},{"node":{"slug":"misconceptions/Python/CannotChainAttributeToObjectInstantiation/","fields":{"slug":"/misconceptions/Python/CannotChainAttributeToObjectInstantiation/","name":"CannotChainAttributeToObjectInstantiation","pl":"Python"},"frontmatter":{"shortDescription":"Method calls, and attribute accesses in general, cannot be chained to a constructor invocation."}}},{"node":{"slug":"misconceptions/Python/ComparisonWithBoolLiteral/","fields":{"slug":"/misconceptions/Python/ComparisonWithBoolLiteral/","name":"ComparisonWithBoolLiteral","pl":"Python"},"frontmatter":{"shortDescription":"To test whether an expression is True or False, one must compare it to True or to False"}}},{"node":{"slug":"misconceptions/Python/ConditionalIsSequence/","fields":{"slug":"/misconceptions/Python/ConditionalIsSequence/","name":"ConditionalIsSequence","pl":"Python"},"frontmatter":{"shortDescription":"If-else is equivalent to sequence of two ifs"}}},{"node":{"slug":"misconceptions/Python/DeferredReturn/","fields":{"slug":"/misconceptions/Python/DeferredReturn/","name":"DeferredReturn","pl":"Python"},"frontmatter":{"shortDescription":"A return statement in the middle of a function doesn't return immediately"}}},{"node":{"slug":"misconceptions/Python/IfIsLoop/","fields":{"slug":"/misconceptions/Python/IfIsLoop/","name":"IfIsLoop","pl":"Python"},"frontmatter":{"shortDescription":"The body of an if-statement executes repeatedly, as long as the condition holds"}}},{"node":{"slug":"misconceptions/Python/InitCreates/","fields":{"slug":"/misconceptions/Python/InitCreates/","name":"InitCreates","pl":"Python"},"frontmatter":{"shortDescription":"__init__ must create a new object"}}},{"node":{"slug":"misconceptions/Python/InitReturnsObject/","fields":{"slug":"/misconceptions/Python/InitReturnsObject/","name":"InitReturnsObject","pl":"Python"},"frontmatter":{"shortDescription":"__init__ needs to return an object"}}},{"node":{"slug":"misconceptions/Python/MapToBooleanWithIf/","fields":{"slug":"/misconceptions/Python/MapToBooleanWithIf/","name":"MapToBooleanWithIf","pl":"Python"},"frontmatter":{"shortDescription":"To map a boolean expression to a bool, an if statement is necessary"}}},{"node":{"slug":"misconceptions/Python/MapToBooleanWithTernaryOperator/","fields":{"slug":"/misconceptions/Python/MapToBooleanWithTernaryOperator/","name":"MapToBooleanWithTernaryOperator","pl":"Python"},"frontmatter":{"shortDescription":"To map a boolean expression to a bool, a ternary conditional operator is necessary"}}},{"node":{"slug":"misconceptions/Python/MultipleValuesReturn/","fields":{"slug":"/misconceptions/Python/MultipleValuesReturn/","name":"MultipleValuesReturn","pl":"Python"},"frontmatter":{"shortDescription":"Functions can return multiple values"}}},{"node":{"slug":"misconceptions/Python/NoAtomicExpression/","fields":{"slug":"/misconceptions/Python/NoAtomicExpression/","name":"NoAtomicExpression","pl":"Python"},"frontmatter":{"shortDescription":"Expressions must consist of more than one piece"}}},{"node":{"slug":"misconceptions/Python/NoEmptyInit/","fields":{"slug":"/misconceptions/Python/NoEmptyInit/","name":"NoEmptyInit","pl":"Python"},"frontmatter":{"shortDescription":"__init__ must do something"}}},{"node":{"slug":"misconceptions/Python/NoReservedWords/","fields":{"slug":"/misconceptions/Python/NoReservedWords/","name":"NoReservedWords","pl":"Python"},"frontmatter":{"shortDescription":"Every sequence of letters and digits starting with a letter or an underscore can be used as an identifier"}}},{"node":{"slug":"misconceptions/Python/NoSequenceRepetition/","fields":{"slug":"/misconceptions/Python/NoSequenceRepetition/","name":"NoSequenceRepetition","pl":"Python"},"frontmatter":{"shortDescription":"There is no operator that repeats sequences"}}},{"node":{"slug":"misconceptions/Python/NoShortCircuit/","fields":{"slug":"/misconceptions/Python/NoShortCircuit/","name":"NoShortCircuit","pl":"Python"},"frontmatter":{"shortDescription":"and/or always evaluate both operands"}}},{"node":{"slug":"misconceptions/Python/NoSingleLogicAnd/","fields":{"slug":"/misconceptions/Python/NoSingleLogicAnd/","name":"NoSingleLogicAnd","pl":"Python"},"frontmatter":{"shortDescription":"& is only a bitwise AND"}}},{"node":{"slug":"misconceptions/Python/ObjectsMustBeNamed/","fields":{"slug":"/misconceptions/Python/ObjectsMustBeNamed/","name":"ObjectsMustBeNamed","pl":"Python"},"frontmatter":{"shortDescription":"A variable is needed to instantiate an object"}}},{"node":{"slug":"misconceptions/Python/OutsideInFunctionNesting/","fields":{"slug":"/misconceptions/Python/OutsideInFunctionNesting/","name":"OutsideInFunctionNesting","pl":"Python"},"frontmatter":{"shortDescription":"Nested function calls are invoked outside in"}}},{"node":{"slug":"misconceptions/Python/ParenthesesOnlyIfArgument/","fields":{"slug":"/misconceptions/Python/ParenthesesOnlyIfArgument/","name":"ParenthesesOnlyIfArgument","pl":"Python"},"frontmatter":{"shortDescription":"() are optional for function calls without arguments"}}},{"node":{"slug":"misconceptions/Python/PlusConcatenatesNumbers/","fields":{"slug":"/misconceptions/Python/PlusConcatenatesNumbers/","name":"PlusConcatenatesNumbers","pl":"Python"},"frontmatter":{"shortDescription":"The plus operator can concatenate strings and numbers"}}},{"node":{"slug":"misconceptions/Python/RecursiveFunctionNeedsIfElse/","fields":{"slug":"/misconceptions/Python/RecursiveFunctionNeedsIfElse/","name":"RecursiveFunctionNeedsIfElse","pl":"Python"},"frontmatter":{"shortDescription":"A recursive function needs to contain an if-else statement"}}},{"node":{"slug":"misconceptions/Python/ReturnCall/","fields":{"slug":"/misconceptions/Python/ReturnCall/","name":"ReturnCall","pl":"Python"},"frontmatter":{"shortDescription":"Return statements need () around the return value"}}},{"node":{"slug":"misconceptions/Python/ReturnUnwindsMultipleFrames/","fields":{"slug":"/misconceptions/Python/ReturnUnwindsMultipleFrames/","name":"ReturnUnwindsMultipleFrames","pl":"Python"},"frontmatter":{"shortDescription":"A return statement can unwind multiple call stack frames"}}},{"node":{"slug":"misconceptions/Python/RightToLeftChaining/","fields":{"slug":"/misconceptions/Python/RightToLeftChaining/","name":"RightToLeftChaining","pl":"Python"},"frontmatter":{"shortDescription":"Chained accesses are invoked from right to left"}}},{"node":{"slug":"misconceptions/Python/SelfAssignable/","fields":{"slug":"/misconceptions/Python/SelfAssignable/","name":"SelfAssignable","pl":"Python"},"frontmatter":{"shortDescription":"Reassigning self changes the object on which a method is called"}}},{"node":{"slug":"misconceptions/Python/SelfNoExpression/","fields":{"slug":"/misconceptions/Python/SelfNoExpression/","name":"SelfNoExpression","pl":"Python"},"frontmatter":{"shortDescription":"The name self is not an expression"}}},{"node":{"slug":"misconceptions/Python/StringLiteralNoObject/","fields":{"slug":"/misconceptions/Python/StringLiteralNoObject/","name":"StringLiteralNoObject","pl":"Python"},"frontmatter":{"shortDescription":"One needs to call str to instantiate a str object from a string literal"}}},{"node":{"slug":"misconceptions/Python/VariablesHoldExpressions/","fields":{"slug":"/misconceptions/Python/VariablesHoldExpressions/","name":"VariablesHoldExpressions","pl":"Python"},"frontmatter":{"shortDescription":"= stores an expression: it stores a reference to the expression in a variable"}}},{"node":{"slug":"misconceptions/Python/VariablesHoldObjects/","fields":{"slug":"/misconceptions/Python/VariablesHoldObjects/","name":"VariablesHoldObjects","pl":"Python"},"frontmatter":{"shortDescription":"A variable contains a whole object"}}},{"node":{"slug":"misconceptions/Scratch/BaseCaseNotNeeded/","fields":{"slug":"/misconceptions/Scratch/BaseCaseNotNeeded/","name":"BaseCaseNotNeeded","pl":"Scratch"},"frontmatter":{"shortDescription":"Recursive computations do not necessarily need a base case"}}},{"node":{"slug":"misconceptions/Scratch/CompareBooleanToConstant/","fields":{"slug":"/misconceptions/Scratch/CompareBooleanToConstant/","name":"CompareBooleanToConstant","pl":"Scratch"},"frontmatter":{"shortDescription":"To test whether an expression evaluates to true or false, one must compare it to a constant"}}},{"node":{"slug":"misconceptions/Scratch/ConditionalIsSequence/","fields":{"slug":"/misconceptions/Scratch/ConditionalIsSequence/","name":"ConditionalIsSequence","pl":"Scratch"},"frontmatter":{"shortDescription":"If-then-else block is equivalent to sequence of two if-then blocks"}}},{"node":{"slug":"misconceptions/Scratch/ElseAlwaysExecutes/","fields":{"slug":"/misconceptions/Scratch/ElseAlwaysExecutes/","name":"ElseAlwaysExecutes","pl":"Scratch"},"frontmatter":{"shortDescription":"The else branch of an if-then-else block always executes"}}},{"node":{"slug":"misconceptions/Scratch/EqualityOperatorComparesListIdentities/","fields":{"slug":"/misconceptions/Scratch/EqualityOperatorComparesListIdentities/","name":"EqualityOperatorComparesListIdentities","pl":"Scratch"},"frontmatter":{"shortDescription":"(list a) = (list b) compares the identities of list a and list b"}}},{"node":{"slug":"misconceptions/Scratch/EqualityOperatorComparesOnlyTypes/","fields":{"slug":"/misconceptions/Scratch/EqualityOperatorComparesOnlyTypes/","name":"EqualityOperatorComparesOnlyTypes","pl":"Scratch"},"frontmatter":{"shortDescription":"() = () compares only the types of its operands"}}},{"node":{"slug":"misconceptions/Scratch/ExpressionAssigns/","fields":{"slug":"/misconceptions/Scratch/ExpressionAssigns/","name":"ExpressionAssigns","pl":"Scratch"},"frontmatter":{"shortDescription":"An expression that reads a variable also updates its value after the evaluation"}}},{"node":{"slug":"misconceptions/Scratch/ListLengthCannotBeZero/","fields":{"slug":"/misconceptions/Scratch/ListLengthCannotBeZero/","name":"ListLengthCannotBeZero","pl":"Scratch"},"frontmatter":{"shortDescription":"A list cannot have a length of 0 items"}}},{"node":{"slug":"misconceptions/Scratch/ListsHomogeneous/","fields":{"slug":"/misconceptions/Scratch/ListsHomogeneous/","name":"ListsHomogeneous","pl":"Scratch"},"frontmatter":{"shortDescription":"All items in a list must have the same type"}}},{"node":{"slug":"misconceptions/Scratch/MissingElseTerminates/","fields":{"slug":"/misconceptions/Scratch/MissingElseTerminates/","name":"MissingElseTerminates","pl":"Scratch"},"frontmatter":{"shortDescription":"Blocks following an if without else will not execute if the condition is false"}}},{"node":{"slug":"misconceptions/Scratch/RepeatDistributes/","fields":{"slug":"/misconceptions/Scratch/RepeatDistributes/","name":"RepeatDistributes","pl":"Scratch"},"frontmatter":{"shortDescription":"Each block in a loop is repeated individually"}}},{"node":{"slug":"misconceptions/Scratch/ResetStateEachLoopIteration/","fields":{"slug":"/misconceptions/Scratch/ResetStateEachLoopIteration/","name":"ResetStateEachLoopIteration","pl":"Scratch"},"frontmatter":{"shortDescription":"The computation of all loop iterations starts from the state before the loop"}}},{"node":{"slug":"misconceptions/Scratch/ResetStateEachProgramExecution/","fields":{"slug":"/misconceptions/Scratch/ResetStateEachProgramExecution/","name":"ResetStateEachProgramExecution","pl":"Scratch"},"frontmatter":{"shortDescription":"Running a Scratch program first resets the state of the world and then executes the program"}}}]},"refs":{"edges":[{"node":{"id":"f0afe23b-5f55-5911-b6e0-b84952c85465","slug":"references/altadmri37MillionCompilations2015","frontmatter":{"langs":["Java"],"method":"Repository mining study (BlueJ Blackbox)","subjects":"250000+ students across the world","artifact":{"url":"https://bluej.org/blackbox/","note":null},"phenomenonKinds":[{"name":"Mistakes","description":"Misunderstandings, type errors, other semantic errors","phenomena":[{"id":"A","name":"Confusing the assignment operator with the comparison operator","observations":[{"kind":"CountOf","measure":"Users making mistake","count":45082,"maxCount":250000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null},{"id":"D","name":"Confusing \"short-circuit\" evaluators with conventional logical operators","observations":[{"kind":"CountOf","measure":"Users making mistake","count":8742,"maxCount":250000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoShortCircuit"},{"lang":"Python","name":"NoShortCircuit"},{"lang":"Java","name":"NoSingleLogicAnd"}],"note":null},{"id":"H","name":"Using keywords as method or variable names","observations":[{"kind":"CountOf","measure":"Users making mistake","count":943,"maxCount":250000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoReservedWords"},{"lang":"Python","name":"NoReservedWords"}],"note":null},{"id":"J","name":"Forgetting parentheses after a method call","observations":[{"kind":"CountOf","measure":"Users making mistake","count":10232,"maxCount":250000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ParenthesesOnlyIfArgument"},{"lang":"Python","name":"ParenthesesOnlyIfArgument"}],"note":null}]}]},"fields":{"slug":"/references/altadmri37MillionCompilations2015/","citationKey":"altadmri37MillionCompilations2015"}}},{"node":{"id":"578fb540-c9f0-5c7c-94b5-01501c5099f5","slug":"references/baymanADiagnosisOfBeginningProgrammersMisconceptions1983","frontmatter":{"langs":["BASIC"],"method":"Quantitative analysis of semantic misinterpretations of selected BASIC language statements","subjects":"30 undergraduate students","artifact":null,"phenomenonKinds":[{"name":"Instruction","description":"Analysis of students' semantic interpretation of a specific BASIC instructions","phenomena":[{"id":"LET A = B + 1","name":" ...write 'B + 1' in memory space A","observations":[{"kind":"Percentage","measure":"Students showing this semantic interpretation","count":null,"maxCount":null,"percent":33,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null}]}]},"fields":{"slug":"/references/baymanADiagnosisOfBeginningProgrammersMisconceptions1983/","citationKey":"baymanADiagnosisOfBeginningProgrammersMisconceptions1983"}}},{"node":{"id":"b5751877-2e80-5bfc-9cd5-ad1b58c9e8ff","slug":"references/bevilacquaAssessingUnderstandingExpressions2024","frontmatter":{"langs":["Java"],"method":"Qualitative and quantitative systematic research","subjects":"542 hand-drawn expression trees from 12 exams in 6 university courses","artifact":{"url":"https://zenodo.org/records/13898595","note":null},"phenomenonKinds":[{"name":"Diagram mistakes","description":"Mistakes in student-drawn expression trees, related to structure, types, or values","phenomena":[{"id":"LiteralInlined","name":"A literal is inlined into the parent node","observations":[{"kind":"CountOf","measure":"Cases","count":41,"maxCount":447,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoAtomicExpression"},{"lang":"JavaScript","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"}],"note":null},{"id":"VariableInlined","name":"A simple variable access or field access is inlined into the parent node","observations":[{"kind":"CountOf","measure":"Cases","count":83,"maxCount":346,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"CallRequiresVariable"},{"lang":"Java","name":"NoAtomicExpression"},{"lang":"Java","name":"ObjectsMustBeNamed"},{"lang":"JavaScript","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"},{"lang":"Python","name":"ObjectsMustBeNamed"}],"note":null},{"id":"TargetInlined","name":"The target (expression before dot) has been inlined (e.g., into a method invocation or a field access with explicit targets).","observations":[{"kind":"CountOf","measure":"Cases","count":97,"maxCount":303,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"CallRequiresVariable"},{"lang":"Java","name":"NoAtomicExpression"},{"lang":"Java","name":"ObjectsMustBeNamed"},{"lang":"JavaScript","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"},{"lang":"Python","name":"ObjectsMustBeNamed"}],"note":null},{"id":"IndexInlined","name":"The index in an array access expression has been inlined.","observations":[{"kind":"CountOf","measure":"Cases","count":25,"maxCount":79,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoAtomicExpression"},{"lang":"JavaScript","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"}],"note":null},{"id":"NewIsolated","name":"Token 'new' is kept in separate node, which possibly includes a hole for connection.","observations":[{"kind":"CountOf","measure":"Cases","count":3,"maxCount":124,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ArrayAllocationWithoutNew"},{"lang":"Java","name":"ConstructorWithoutNew"}],"note":null},{"id":"RightToLeftAssociativity","name":"Binary operator that is left-to-right associative is treated as right-to-left associative.","observations":[{"kind":"CountOf","measure":"Cases","count":15,"maxCount":49,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ArithmeticPlusPrecedes"}],"note":null},{"id":"TreeIsChainInSourceOrder","name":"The tree is primarily a chain, reflecting, in order (e.g., left to right -> top to bottom) the constructs of the source code.","observations":[{"kind":"CountOf","measure":"Cases","count":5,"maxCount":40,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"RightToLeftChaining"},{"lang":"Python","name":"RightToLeftChaining"}],"note":null},{"id":"SubstitutionTakenFromEvaluation","name":"A node is replaced with a subtree containing code that appears inside methods or constructors called by the expression.","observations":[{"kind":"CountOf","measure":"Cases","count":62,"maxCount":480,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null},{"id":"ImplicitThis","name":"An *implicit* this is explicitly reported in the expression tree.","observations":[{"kind":"CountOf","measure":"Cases","count":1,"maxCount":139,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":null,"name":null}],"note":null},{"id":"ArrayLengthWithParentheses","name":"Access to the length field of an array is represented with extra parentheses.","observations":[{"kind":"CountOf","measure":"Cases","count":1,"maxCount":44,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ArrayHasLengthMethod"}],"note":null},{"id":"ParameterlessWithoutParentheses","name":"A method / constructor with no arguments is represented in the tree with its proper name but without parentheses.","observations":[{"kind":"CountOf","measure":"Cases","count":12,"maxCount":266,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ParenthesesOnlyIfArgument"},{"lang":"Python","name":"ParenthesesOnlyIfArgument"}],"note":null},{"id":"InstantiationWithoutNew","name":"Missing token 'new' in a class, interface, or array instance creation.","observations":[{"kind":"CountOf","measure":"Cases","count":26,"maxCount":124,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ArrayAllocationWithoutNew"},{"lang":"Java","name":"ConstructorWithoutNew"}],"note":null},{"id":"LiteralWithoutType","name":"A literal is missing the type annotation.","observations":[{"kind":"CountOf","measure":"Cases","count":25,"maxCount":406,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"LiteralNoExpression"},{"lang":"Java","name":"NoAtomicExpression"},{"lang":"JavaScript","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"}],"note":null},{"id":"VariableWithoutType","name":"A simple variable access is missing the type annotation.","observations":[{"kind":"CountOf","measure":"Cases","count":14,"maxCount":322,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoAtomicExpression"},{"lang":"JavaScript","name":"NoAtomicExpression"}],"note":null},{"id":"TypeIsParentHoleType","name":"The type of the node is not the actual type of the node, but rather the type specified for the surrounding 'hole'.","observations":[{"kind":"CountOf","measure":"Cases","count":17,"maxCount":64,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"TargetTyping"}],"note":null},{"id":"CharacterTypeString","name":"The type of a character literal node is String.","observations":[{"kind":"CountOf","measure":"Cases","count":11,"maxCount":53,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"SingleQuoteString"}],"note":null},{"id":"LiteralWithoutValue","name":"A literal is missing the value annotation.","observations":[{"kind":"CountOf","measure":"Cases","count":61,"maxCount":159,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"LiteralNoExpression"},{"lang":"Java","name":"NoAtomicExpression"},{"lang":"JavaScript","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"}],"note":null},{"id":"VariableWithoutValue","name":"A simple variable access is missing the value annotation.","observations":[{"kind":"CountOf","measure":"Cases","count":17,"maxCount":115,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoAtomicExpression"},{"lang":"JavaScript","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"}],"note":null},{"id":"StringValueWithoutQuotes","name":"String value reported without quotes.","observations":[{"kind":"CountOf","measure":"Cases","count":9,"maxCount":328,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"LiteralString"}],"note":null},{"id":"BothBranchesOfCondExprEvaluated","name":"Both branches of a conditional expression are annotated with values.","observations":[{"kind":"CountOf","measure":"Cases","count":67,"maxCount":115,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ElseAlwaysExecutes"}],"note":null}]}]},"fields":{"slug":"/references/bevilacquaAssessingUnderstandingExpressions2024/","citationKey":"bevilacquaAssessingUnderstandingExpressions2024"}}},{"node":{"id":"f5abd37e-c967-5aa8-bab9-3bef6628f2f8","slug":"references/brownNoviceJavaProgrammingMistakes2017","frontmatter":{"langs":["Java"],"method":"Quantitative systematic research analyzing 100+ M compilation events and surveying educators perceptions about 18 selected mistakes","subjects":"900+ students and 76 educators","artifact":null,"phenomenonKinds":[{"name":"Errors","description":"A Blackbox dataset of student-generated compilation events over a 2-year period.","phenomena":[{"id":"(A)eqSyn","name":"Confusing the assignment operator (=) with the equality operator (==)","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":405748,"maxCount":100000000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null},{"id":"(D)andOrSyn","name":"Confusing short-circuit evaluators (&& and||) with conventional logical operators (& and|)","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":61965,"maxCount":100000000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoShortCircuit"},{"lang":"Python","name":"NoShortCircuit"}],"note":null},{"id":"(H)keySyn","name":"Using keywords as methods' or variables' names","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":2568,"maxCount":100000000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoReservedWords"},{"lang":"Python","name":"NoReservedWords"}],"note":null},{"id":"(J)parCalSyn","name":"Forgetting parentheses after a method call","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":43165,"maxCount":100000000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ParenthesesOnlyIfArgument"},{"lang":"Python","name":"ParenthesesOnlyIfArgument"}],"note":null},{"id":"(R)impSem","name":"A class claims to implement an interface but does not implement all the required methods","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":107,"maxCount":100000000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ImplicitInterfaceImplementation"}],"note":null}]}]},"fields":{"slug":"/references/brownNoviceJavaProgrammingMistakes2017/","citationKey":"brownNoviceJavaProgrammingMistakes2017"}}},{"node":{"id":"d55e1ffb-4d92-58c5-b729-4bc1dfbe576f","slug":"references/caceffoIdentifyingValidatingJava2019","frontmatter":{"langs":["Java"],"method":"Quantitative systematic research","subjects":"69 upper-level undergraduate students","artifact":{"url":"https://www.ic.unicamp.br/~reltech/2019/19-05.pdf","note":null},"phenomenonKinds":[{"name":"Misconceptions","description":"Java misconceptions on (A) function parameter use and scope, (B) variables, identifiers, and scope, (C) recursion, (D) iteration, (E) structures, (F) pointers, (G) boolean expressions, and (H) classes and objects.","phenomena":[{"id":"F.4","name":"Void function returns value","observations":[{"kind":"CountOf","measure":"Students holding misconception","count":1,"maxCount":69,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VoidMethodReturnsValue"}],"note":null}]}]},"fields":{"slug":"/references/caceffoIdentifyingValidatingJava2019/","citationKey":"caceffoIdentifyingValidatingJava2019"}}},{"node":{"id":"dae7fd67-4962-5ea5-96c2-5f54e851787d","slug":"references/chiodiniSurveyingUpperSecondaryTeachers2025","frontmatter":{"langs":["Python"],"method":"Quantitative systematic research","subjects":"97 Swiss high school teachers and their students","artifact":{"url":"https://zenodo.org/records/15633868","note":null},"phenomenonKinds":[{"name":"Programming Language Misconceptions","description":"Misconceptions that directly correspond to Progmiscon.org misconceptions","phenomena":[{"id":"NAE","name":"NoAtomicExpression","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":39,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":42,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[18,25,26,18,10],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[8,16,9,40,24],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoAtomicExpression"},{"lang":"Python","name":"NoAtomicExpression"},{"lang":"JavaScript","name":"NoAtomicExpression"}],"note":null},{"id":"RUMF","name":"ReturnUnwindsMultipleFrames","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":37,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":45,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[34,26,15,11,11],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[3,12,11,54,17],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ReturnUnwindsMultipleFrames"},{"lang":"Python","name":"ReturnUnwindsMultipleFrames"}],"note":null},{"id":"CIS","name":"ConditionalIsSequence","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":34,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":78,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[51,28,8,5,5],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[16,34,16,21,10],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ConditionalIsSequence"},{"lang":"Python","name":"ConditionalIsSequence"}],"note":null},{"id":"NSC","name":"NoShortCircuit","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":30,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":68,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[18,28,35,11,5],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[7,19,20,33,18],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoShortCircuit"},{"lang":"Python","name":"NoShortCircuit"}],"note":null},{"id":"MVR","name":"MultipleValuesReturn","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":29,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":61,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[32,34,23,5,3],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[3,24,19,32,19],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Python","name":"MultipleValuesReturn"}],"note":null},{"id":"ACO","name":"AssignmentCopiesObject","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":26,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":74,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[46,28,9,6,8],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[13,35,13,18,18],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignmentCopiesObject"},{"lang":"Python","name":"AssignmentCopiesObject"},{"lang":"JavaScript","name":"AssignmentCopiesObject"}],"note":null},{"id":"MTBWI","name":"MapToBooleanWithIf","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":25,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":73,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[10,38,26,17,6],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[18,37,15,15,12],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"MapToBooleanWithIf"},{"lang":"Python","name":"MapToBooleanWithIf"}],"note":null},{"id":"CWBL","name":"ComparisonWithBoolLiteral","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":21,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":82,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[12,30,34,19,2],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[28,34,15,10,10],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ComparisonWithBooleanLiteral"},{"lang":"Python","name":"ComparisonWithBoolLiteral"},{"lang":"Scratch","name":"CompareBooleanToConstant"}],"note":null},{"id":"RC","name":"ReturnCall","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":19,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":60,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[11,17,30,34,5],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[18,21,23,24,11],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ReturnCall"},{"lang":"Python","name":"ReturnCall"}],"note":null},{"id":"POIA","name":"ParenthesesOnlyIfArgument","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":15,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":81,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[68,17,8,2,2],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[33,30,18,14,2],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ParenthesesOnlyIfArgument"},{"lang":"Python","name":"ParenthesesOnlyIfArgument"}],"note":null},{"id":"NRW","name":"NoReservedWords","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":14,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":83,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[46,25,21,4,1],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[9,21,37,26,4],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"NoReservedWords"},{"lang":"Python","name":"NoReservedWords"}],"note":null},{"id":"OIFN","name":"OutsideInFunctionNesting","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":11,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":64,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[55,26,8,1,7],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[6,21,15,46,9],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"OutsideInMethodNesting"},{"lang":"Python","name":"OutsideInFunctionNesting"}],"note":null},{"id":"DR","name":"DeferredReturn","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":9,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":71,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[64,28,4,0,1],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[14,32,21,24,6],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"DeferredReturn"},{"lang":"Python","name":"DeferredReturn"}],"note":null},{"id":"VHE","name":"VariablesHoldExpressions","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":8,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":58,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[63,14,10,3,7],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[7,24,17,42,7],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null},{"id":"IIL","name":"IfIsLoop","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":4,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":43,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[62,19,9,3,4],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[7,17,17,51,5],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"IfIsLoop"},{"lang":"Python","name":"IfIsLoop"}],"note":null},{"id":"AC","name":"AssignCompares","observations":[{"kind":"CountOf","measure":"Teachers hold misconception","count":3,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"CountOf","measure":"Teachers familiar with misconception","count":85,"maxCount":97,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Importance (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[71,19,5,1,1],"levelLabels":["Important","Somewhat Important","Not So Important","Not Important","I'm not sure"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null},{"kind":"Likert","measure":"Prevalence in students (reported by teachers)","count":null,"maxCount":null,"percent":null,"counts":[30,38,14,10,5],"levelLabels":["Frequently","Multiple Times","At Least Once","Never","I don't know"],"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null}]}]},"fields":{"slug":"/references/chiodiniSurveyingUpperSecondaryTeachers2025/","citationKey":"chiodiniSurveyingUpperSecondaryTeachers2025"}}},{"node":{"id":"e17590ec-8a27-5ac9-8581-8b40cd6bc740","slug":"references/duboulayDifficultiesLearningProgram1986","frontmatter":{"langs":["Pascal","BASIC"],"method":"Argumentation, review of prior work","subjects":"No explicitly mentioned subjects","artifact":null,"phenomenonKinds":[{"name":"Difficulties","description":"Difficulties","phenomena":[{"id":"Page66","name":"Variable holds an unevaluated expression","observations":null,"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null}]}]},"fields":{"slug":"/references/duboulayDifficultiesLearningProgram1986/","citationKey":"duboulayDifficultiesLearningProgram1986"}}},{"node":{"id":"8ddac49a-912c-5da1-803c-6cd188b6f580","slug":"references/groverMeasuringStudentLearning2017","frontmatter":{"langs":["Scratch"],"method":"Quantitative systematic research","subjects":"100 grade 6, 7, and 8 students","artifact":null,"phenomenonKinds":[{"name":"Items","description":"Items assessing misconceptions on loops, variables, and logic","phenomena":[{"id":"2a","name":"Grouping the actions in the loop (Item 2a code 'Grouped')","observations":[{"kind":"CountOf","measure":"Students making this error","count":8,"maxCount":100,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"RepeatDistributes"}],"note":null},{"id":"8d","name":"Loops produce the exact same output in every iteration (Item 8d)","observations":[{"kind":"Categorical","measure":"Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":"More than 96%","categoryDescription":"Less than 4% of the students got this item correct"}],"plMisconceptions":[{"lang":"Scratch","name":"ResetStateEachLoopIteration"}],"note":null}]}]},"fields":{"slug":"/references/groverMeasuringStudentLearning2017/","citationKey":"groverMeasuringStudentLearning2017"}}},{"node":{"id":"2b96b1b4-3524-5fa3-a08b-926614baa029","slug":"references/hartmannPrevalenceProgrammingMisconceptions2024","frontmatter":{"langs":["Scratch","xLogo"],"method":"Quantitative systematic research","subjects":"366 grade 5 or 6 students (255 for Scratch, 111 for xLogo)","artifact":{"url":"https://osf.io/5bxvp/?view_only=d6a51b4cfdfb4e63887fde5da9ef66c7","note":"The ProMAT Scratch 1.3 test for this study is in 'ProMAT Scratch 1.3 annotated copy of online test.pdf'. (The same OSF project contains files for this study and their 2022 study.)"},"phenomenonKinds":[{"name":"Scratch Misconceptions","description":"Misconceptions detected with ProMAT Scratch 1.3 (on sequences, loops, conditionals, superbug)","phenomena":[{"id":"C2","name":"A false condition ends program if no ELSE branch (26 in Sorva's list)","observations":[{"kind":"CountOf","measure":"Students with this misconception","count":32,"maxCount":255,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"MissingElseTerminates"}],"note":"Percentage in paper (Figure 2, 12.3%) does not correspond to a whole number of students out of the reported 67+188=255 Scratch students"},{"id":"L5","name":"When there are multiple actions inside a loop, instead of executing a sequence of actions in a loop and then repeating the entire sequence, some students tend to repeat each action separately before repeating the subsequent action(s), thus grouping the actions in the loop. (n2)","observations":[{"kind":"CountOf","measure":"Students with this misconception","count":103,"maxCount":255,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"RepeatDistributes"}],"note":"Percentage in paper (Figure 2, 40.5%) does not correspond to a whole number of students out of the reported 67+188=255 Scratch students"},{"id":"Item P9","name":"Each time a scratch program is executed it starts in the same initial state","observations":[{"kind":"CountOf","measure":"Students with this misconception","count":113,"maxCount":255,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"ResetStateEachProgramExecution"}],"note":"The paper maps test item P9 in ProMAT Scratch 1.3 to L6 (aka n3) 'Students ... expected loops to produce the exact same output in every iteration', which corresponds to ResetStateEachLoopIteration. However, item P9 is about reexecuting the entire program, by clicking on the green flag, and not about executing just another loop iteration. Thus, we associate item P9 with ResetStateEachProgramExecution. Also, the percentage in paper (Figure 2, 44.5%) does not correspond to a whole number of students out of the reported 67+188=255 Scratch students."}]}]},"fields":{"slug":"/references/hartmannPrevalenceProgrammingMisconceptions2024/","citationKey":"hartmannPrevalenceProgrammingMisconceptions2024"}}},{"node":{"id":"4d5b3d2c-5a3d-5792-b6ba-0a4be9e859e4","slug":"references/hartmannProgrammingConceptsMisconceptions2022","frontmatter":{"langs":["Scratch"],"method":"Quantitative systematic research","subjects":"57 grade 5 or 6 students","artifact":{"url":"https://osf.io/5bxvp/?view_only=76b81b0a145e4836a0468773fe9eb1aa","note":"The ProMAT 1.1 tests for this study are in 'old Test versions', the results for this study are in 'data_Pilot.csv'. (The same OSF project contains files for this study and their 2024 study.)"},"phenomenonKinds":[{"name":"Mistakes in Test Items","description":"ProMAT 1.1 (Scratch) Test Items","phenomena":[{"id":"P5","name":"ProMAT 1.1, Aufgabe P5","observations":[{"kind":"CountOf","measure":"Students making this error","count":0,"maxCount":57,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"MissingElseTerminates"}],"note":"Information taken from artifact, paper does not show these details"},{"id":"P11","name":"ProMAT 1.1, Aufgabe P11","observations":[{"kind":"CountOf","measure":"Students making this error","count":2,"maxCount":57,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"MissingElseTerminates"}],"note":"Information taken from artifact, paper does not show these details"},{"id":"P13","name":"ProMAT 1.1, Aufgabe P13","observations":[{"kind":"CountOf","measure":"Students making this error","count":7,"maxCount":57,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"MissingElseTerminates"}],"note":"Information taken from artifact, paper does not show these details"},{"id":"P8","name":"ProMAT 1.1, Aufgabe P8","observations":[{"kind":"CountOf","measure":"Students making this error","count":12,"maxCount":57,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"RepeatDistributes"}],"note":"Information taken from artifact, paper does not show these details"},{"id":"P9","name":"ProMAT 1.1, Aufgabe P9","observations":[{"kind":"CountOf","measure":"Students making this error","count":0,"maxCount":57,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Scratch","name":"ResetStateEachLoopIteration"}],"note":"Information taken from artifact, paper does not show these details"}]}]},"fields":{"slug":"/references/hartmannProgrammingConceptsMisconceptions2022/","citationKey":"hartmannProgrammingConceptsMisconceptions2022"}}},{"node":{"id":"6baa5715-0e22-5cf8-90bd-2f97a08f66d5","slug":"references/hristovaIdentifyingCorrectingJava2003","frontmatter":{"langs":["Java"],"method":"Qualitative (survey of instructors and students)","subjects":"Unknown number of undergraduate students, professors, SIGCSE members","artifact":null,"phenomenonKinds":[{"name":"Errors","description":"Common syntax, semantic, and logic errors in Java","phenomena":[{"id":"Syntax1","name":"Confusing the assignment operator with the comparison operator","observations":null,"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null},{"id":"Syntax2","name":"Use of == instead of .equals to compare strings","observations":null,"plMisconceptions":[{"lang":"Java","name":"EqualityOperatorComparesObjectsValues"}],"note":null},{"id":"Syntax4","name":"Confusing \"short-circuit\" evaluators with conventional logical operators","observations":null,"plMisconceptions":[{"lang":"Java","name":"NoSingleLogicAnd"},{"lang":"Java","name":"NoShortCircuit"},{"lang":"Python","name":"NoShortCircuit"}],"note":null},{"id":"Syntax8","name":"Using keywords as method or variable names","observations":null,"plMisconceptions":[{"lang":"Java","name":"NoReservedWords"},{"lang":"Python","name":"NoReservedWords"}],"note":null},{"id":"Syntax10","name":"Forgetting parentheses after a method call","observations":null,"plMisconceptions":[{"lang":"Java","name":"ParenthesesOnlyIfArgument"},{"lang":"Python","name":"ParenthesesOnlyIfArgument"}],"note":null}]}]},"fields":{"slug":"/references/hristovaIdentifyingCorrectingJava2003/","citationKey":"hristovaIdentifyingCorrectingJava2003"}}},{"node":{"id":"407c186d-2c95-5e34-ad56-e9fd95b6ba90","slug":"references/kaczmarczykIdentifyingStudentMisconceptions2010","frontmatter":{"langs":["Java"],"method":"Qualitative (interviews)","subjects":"10 undergraduate students","artifact":null,"phenomenonKinds":[{"name":"Misconceptions","description":"Misconceptions related to memory","phenomena":[{"id":"PVR1","name":"Primitive no default","observations":null,"plMisconceptions":null,"note":null},{"id":"MMR4","name":"Uninstantiated memory allocation","observations":null,"plMisconceptions":null,"note":null}]}]},"fields":{"slug":"/references/kaczmarczykIdentifyingStudentMisconceptions2010/","citationKey":"kaczmarczykIdentifyingStudentMisconceptions2010"}}},{"node":{"id":"b42182b4-6ebe-5f00-8492-6b53eb966f92","slug":"references/maInvestigatingImprovingModelOfProgramming2011","frontmatter":{"langs":["Java"],"method":"Quantitative and qualitative analysis of incorrect mental models related to variable assignment using open-ended testing","subjects":"60 novice students","artifact":null,"phenomenonKinds":[{"name":"Mental model","description":"Incorrect mental models related to variable assignment among tested students.","phenomena":[{"id":"ME","name":"Viewing '=' as a comparison operator","observations":[{"kind":"CountOf","measure":"Students showing this (incorrect) mental model","count":6,"maxCount":60,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null}]}]},"fields":{"slug":"/references/maInvestigatingImprovingModelOfProgramming2011/","citationKey":"maInvestigatingImprovingModelOfProgramming2011"}}},{"node":{"id":"dd9e18ab-ea66-5e3d-95d4-b89f2b75e84e","slug":"references/mccallANewLookatNoviceProgrammingErrors","frontmatter":{"langs":["Java"],"method":"Quantitative systematic research analyzing 1000+ randomly-selected compilation events","subjects":"199 user sessions (each sessions associated with a different user)","artifact":{"url":"https://bluej.org/blackbox/","note":"The paper's appendices contain most of the underlying data. The raw data would be available in the Blackbox dataset, however, the information about which 199 user sessions were randomly selected (within the period from 2013-06-11 to 2014-05-30) from the Blackbox dataset is not provided."},"phenomenonKinds":[{"name":"Errors","description":"A Blackbox dataset of randomly-selected, student-generated compilation events over a 1-year period.","phenomena":[{"id":"Tab8.2","name":"Variable not declared","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":85,"maxCount":1000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"UndeclaredVariables"}],"note":"The exact total number of errors studied is unclear (the paper states 'a total of (just over) 1,000 compilation events with errors'.)"},{"id":"Tab8.27","name":"Method declaration: missing return type","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":10,"maxCount":1000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"MethodWithoutReturnType"}],"note":"The exact total number of errors studied is unclear (the paper states 'a total of (just over) 1,000 compilation events with errors'.)"},{"id":"Tab8.18","name":"Missing parentheses for method call","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":21,"maxCount":1000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ParenthesesOnlyIfArgument"},{"lang":"Python","name":"ParenthesesOnlyIfArgument"}],"note":"The exact total number of errors studied is unclear (the paper states 'a total of (just over) 1,000 compilation events with errors'.)"},{"id":"Tab8.33","name":"'=' used in place of '=='","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":6,"maxCount":1000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":"The exact total number of errors studied is unclear (the paper states 'a total of (just over) 1,000 compilation events with errors'.)"},{"id":"Tab8.46","name":"Class does not implement required method","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":2,"maxCount":1000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ImplicitInterfaceImplementation"},{"lang":"Java","name":"ConcreteClassOnlyImplementClassAbstract"},{"lang":"Java","name":"ConcreteClassOnlyImplementDirectAbstract"},{"lang":"Java","name":"ConcreteClassOnlyImplementInterfaceAbstract"}],"note":"The exact total number of errors studied is unclear (the paper states 'a total of (just over) 1,000 compilation events with errors'.)"},{"id":"Tab8.60","name":"Local variable declaration with illegal modifier","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":1,"maxCount":1000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ControlledLocalAccess"}],"note":"The exact total number of errors studied is unclear (the paper states 'a total of (just over) 1,000 compilation events with errors'.)"},{"id":"Tab8.69","name":"Constructor call without using 'new'","observations":[{"kind":"CountOf","measure":"Compilation events containing this error","count":0,"maxCount":1000,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ConstructorWithoutNew"}],"note":"The exact total number of errors studied is unclear (the paper states 'a total of (just over) 1,000 compilation events with errors'.)"}]}]},"fields":{"slug":"/references/mccallANewLookatNoviceProgrammingErrors/","citationKey":"mccallANewLookatNoviceProgrammingErrors"}}},{"node":{"id":"8115b95c-80f2-5bb8-997d-de4dd2004a34","slug":"references/putnamSummaryMisconceptionsHigh1986","frontmatter":{"langs":["BASIC"],"method":"Qualitative study (interviews)","subjects":"56 high school students showing significant difficulties in a screening test","artifact":null,"phenomenonKinds":[{"name":"Misconceptions","description":"Misconceptions in BASIC","phenomena":[{"id":"IF1","name":"When the condition of an IF statement is false, execution of the entire program terminates","observations":[{"kind":"Categorical","measure":"Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":"Occasional","categoryDescription":"Observed in 1...5 out of 56 students"}],"plMisconceptions":[{"lang":"Scratch","name":"MissingElseTerminates"}],"note":null}]}]},"fields":{"slug":"/references/putnamSummaryMisconceptionsHigh1986/","citationKey":"putnamSummaryMisconceptionsHigh1986"}}},{"node":{"id":"03614f2f-a24f-5bdd-ab23-93a1145acbb3","slug":"references/ragonisLongtermInvestigationComprehension2005","frontmatter":{"langs":["Java"],"method":"Qualitative study (observations and field notes, audio and video recordings, and collection of artifacts)","subjects":"47 grade 10 students","artifact":null,"phenomenonKinds":[{"name":"Misconceptions/Difficulties","description":"Misconceptions and difficulties related to OOP in Java","phenomena":[{"id":"1.1.3","name":"You can define a method that adds an attribute to the class","observations":null,"plMisconceptions":[{"lang":"Java","name":"AddMemberAtRuntime"}],"note":null},{"id":"2.3.1","name":"Difficulties understanding the empty constructor","observations":null,"plMisconceptions":[{"lang":"Java","name":"ConstructorAllocates"},{"lang":"Java","name":"ConstructorReturnsObject"},{"lang":"Java","name":"MustInitializeFieldInConstructor"},{"lang":"Java","name":"NoEmptyConstructor"},{"lang":"Python","name":"NoEmptyInit"}],"note":null}]}]},"fields":{"slug":"/references/ragonisLongtermInvestigationComprehension2005/","citationKey":"ragonisLongtermInvestigationComprehension2005"}}},{"node":{"id":"9d2cda7a-ec18-5de4-8c79-0ba9cb08d811","slug":"references/rodrigoAnAnalysisOfJavaProgramming2013","frontmatter":{"langs":["Java"],"method":"Qualitative and quantitative study analyzing about 190'000 compilation logs","subjects":"180 undergraduates","artifact":null,"phenomenonKinds":[{"name":"Errors","description":"Qualitative, sample-based observations of code snippets","phenomena":[{"id":"Fig11","name":"Code snippet showing a use of '=' as comparator","observations":null,"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null},{"id":"Pag20","name":"[Students] forget to use a '( )' after the name of a method with no parameters","observations":null,"plMisconceptions":[{"lang":"Java","name":"ParenthesesOnlyIfArgument"},{"lang":"Python","name":"ParenthesesOnlyIfArgument"}],"note":null},{"id":"Fig12","name":"Some students put statements after a return [...]","observations":null,"plMisconceptions":[{"lang":"Java","name":"DeferredReturn"},{"lang":"Python","name":"DeferredReturn"}],"note":null},{"id":"Fig14","name":"Students also make the mistake of assigning values to parameters instead of using the parameters to initialize field variables","observations":null,"plMisconceptions":[{"lang":"Java","name":"ConstructorParameterIsField"}],"note":null}]}]},"fields":{"slug":"/references/rodrigoAnAnalysisOfJavaProgramming2013/","citationKey":"rodrigoAnAnalysisOfJavaProgramming2013"}}},{"node":{"id":"fbd55579-9697-5bec-9145-11631b1b4ddc","slug":"references/sleemanPascalHighSchool1986","frontmatter":{"langs":["Pascal"],"method":"Qualitative study (interviews)","subjects":"35 high-school students showing significant difficulties in a screening test","artifact":null,"phenomenonKinds":[{"name":"Errors","description":"Errors with Pascal constructs","phenomena":[{"id":"IF1","name":"Program execution is halted if the condition is false and there is no ELSE branch","observations":[{"kind":"Categorical","measure":"Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":"Occasional","categoryDescription":"Observed in 1...3 out of 35 students"}],"plMisconceptions":[{"lang":"Scratch","name":"MissingElseTerminates"}],"note":null}]}]},"fields":{"slug":"/references/sleemanPascalHighSchool1986/","citationKey":"sleemanPascalHighSchool1986"}}},{"node":{"id":"809f9c4f-1878-515f-9433-2836c05ddd39","slug":"references/swidanProgrammingMisconceptionsSchool2018","frontmatter":{"langs":["Scratch"],"method":"Quantitative systematic research","subjects":"145 participants aged 7-17 with programming experience","artifact":{"url":"https://drive.google.com/file/d/1Rea75Gjqq4kDGlYBojSnINA96YRXfh_m/view","note":null},"phenomenonKinds":[{"name":"Programming Misconceptions","description":"Misconceptions from Sorva's list","phenomena":[{"id":"M15","name":"Primitive assignment stores equations or unresolved expressions","observations":[{"kind":"CountOf","measure":"Participants hold misconception","count":16,"maxCount":63,"percent":null,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null}]}]},"fields":{"slug":"/references/swidanProgrammingMisconceptionsSchool2018/","citationKey":"swidanProgrammingMisconceptionsSchool2018"}}},{"node":{"id":"eefc532a-920f-59c4-8545-73c4a55c177b","slug":"references/qianTeachersPerceptionsStudent2020","frontmatter":{"langs":["Python"],"method":"A quantitative survey of teachers to assess their perceptions of the frequency and importance of student misconceptions","subjects":"44 high school teachers","artifact":null,"phenomenonKinds":[{"name":"Misconceptions","description":"Survey about 37 pre-selected misconceptions","phenomena":[{"id":"AppendixA.1(F)","name":"A variable can hold more than one value at the same time","observations":[{"kind":"Scale","measure":"Average Perceived Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":2.14,"maxValue":4,"maxLabel":"Very Frequent","minValue":1,"minLabel":"Never","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"MultiValueVariable"}],"note":null},{"id":"AppendixA.1(I)","name":"A variable can hold more than one value at the same time","observations":[{"kind":"Scale","measure":"Average Importance Rating","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":3.19,"maxValue":4,"maxLabel":"Very Important","minValue":1,"minLabel":"Not Important","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"MultiValueVariable"}],"note":null},{"id":"AppendixA.3(F)","name":"The assignment statement A = B + 1 changes the value of B by 1, as well as changing A","observations":[{"kind":"Scale","measure":"Average Perceived Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":1.93,"maxValue":4,"maxLabel":"Very Frequent","minValue":1,"minLabel":"Never","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ExpressionAssigns"},{"lang":"Scratch","name":"ExpressionAssigns"}],"note":null},{"id":"AppendixA.3(I)","name":"The assignment statement A = B + 1 changes the value of B by 1, as well as changing A","observations":[{"kind":"Scale","measure":"Average Importance Rating","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":2.98,"maxValue":4,"maxLabel":"Very Important","minValue":1,"minLabel":"Not Important","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"ExpressionAssigns"},{"lang":"Scratch","name":"ExpressionAssigns"}],"note":null},{"id":"AppendixA.4(F)","name":"Assigning the value of a variable to another variable 'links' the two variables, so changing the value of one changes the value of the other","observations":[{"kind":"Scale","measure":"Average Perceived Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":2.19,"maxValue":4,"maxLabel":"Very Frequent","minValue":1,"minLabel":"Never","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"},{"lang":"Java","name":"ReferenceToVariable"}],"note":null},{"id":"AppendixA.4(I)","name":"Assigning the value of a variable to another variable 'links' the two variables, so changing the value of one changes the value of the other","observations":[{"kind":"Scale","measure":"Average Importance Rating","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":3.3,"maxValue":4,"maxLabel":"Very Important","minValue":1,"minLabel":"Not Important","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"},{"lang":"Java","name":"ReferenceToVariable"}],"note":null},{"id":"AppendixA.5(F)","name":"The assignment statement a = b + 1 stores the formula 'b + 1' in a rather than the value of b + 1","observations":[{"kind":"Scale","measure":"Average Perceived Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":1.98,"maxValue":4,"maxLabel":"Very Frequent","minValue":1,"minLabel":"Never","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null},{"id":"AppendixA.5(I)","name":"The assignment statement a = b + 1 stores the formula 'b + 1' in a rather than the value of b + 1","observations":[{"kind":"Scale","measure":"Average Importance Rating","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":2.88,"maxValue":4,"maxLabel":"Very Important","minValue":1,"minLabel":"Not Important","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null},{"id":"AppendixA.19(F)","name":"The symbol '=' tests for equality","observations":[{"kind":"Scale","measure":"Average Perceived Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":2.93,"maxValue":4,"maxLabel":"Very Frequent","minValue":1,"minLabel":"Never","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null},{"id":"AppendixA.19(I)","name":"The symbol '=' tests for equality","observations":[{"kind":"Scale","measure":"Average Importance Rating","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":3.4,"maxValue":4,"maxLabel":"Very Important","minValue":1,"minLabel":"Not Important","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignCompares"},{"lang":"Python","name":"AssignCompares"}],"note":null},{"id":"AppendixA.14(F)","name":"Strings can be defined without quotation marks [...]","observations":[{"kind":"Scale","measure":"Average Perceived Frequency","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":2.36,"maxValue":4,"maxLabel":"Very Frequent","minValue":1,"minLabel":"Never","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"LiteralString"}],"note":null},{"id":"AppendixA.14(I)","name":"Strings can be defined without quotation marks [...]","observations":[{"kind":"Scale","measure":"Average Importance Rating","count":null,"maxCount":null,"percent":null,"counts":null,"levelLabels":null,"value":3.17,"maxValue":4,"maxLabel":"Very Important","minValue":1,"minLabel":"Not Important","category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"LiteralString"}],"note":null}]}]},"fields":{"slug":"/references/qianTeachersPerceptionsStudent2020/","citationKey":"qianTeachersPerceptionsStudent2020"}}},{"node":{"id":"e8adcb79-2b10-5bf0-ad24-26163eb712ca","slug":"references/zankoAnalysisOfSchoolStudentsMisconceptions2021","frontmatter":{"langs":["Python"],"method":"Quantitative analysis of student misconceptions about basic programming concepts through split exams spanning 2 sessions, months apart","subjects":"98 elementary school students","artifact":null,"phenomenonKinds":[{"name":"Exam question","description":"Analysis of answers to specific questions asked within an exam","phenomena":[{"id":"Table8(a)","name":"Assigning the expression instead of the calculated value","observations":[{"kind":"Percentage","measure":"Students providing wrong answers (mean)","count":null,"maxCount":null,"percent":21.94,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null}]}]},"fields":{"slug":"/references/zankoAnalysisOfSchoolStudentsMisconceptions2021/","citationKey":"zankoAnalysisOfSchoolStudentsMisconceptions2021"}}},{"node":{"id":"c1590299-4d87-5928-a73e-00d22e8b9331","slug":"references/luIdentifyingCorrectingProgramming2024","frontmatter":{"langs":["SMoL"],"method":"Quantitative systematic research","subjects":"Students from 2 universities and other users of online textbook","artifact":{"url":"https://dl.acm.org/do/10.1145/3580432/full/","note":null},"phenomenonKinds":[{"name":"Programming Language Behavior Misconceptions","description":"Misconceptions about program semantics identified by SMoL Tutor","phenomena":[{"id":"CallByRef","name":"Function calls alias variables","observations":[{"kind":"Percentage","measure":"Learners hold misconception","count":null,"maxCount":null,"percent":10,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null},{"id":"CallsCopyStructs","name":"Function calls copy data structures","observations":[{"kind":"Percentage","measure":"Learners hold misconception","count":null,"maxCount":null,"percent":10,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignmentCopiesObject"},{"lang":"Python","name":"AssignmentCopiesObject"},{"lang":"JavaScript","name":"AssignmentCopiesObject"}],"note":null},{"id":"DefByRef","name":"Variable definitions alias variables","observations":[{"kind":"Percentage","measure":"Learners hold misconception","count":null,"maxCount":null,"percent":12,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null},{"id":"DefsCopyStructs","name":"Variable definitions copy structures recursively","observations":[{"kind":"Percentage","measure":"Learners hold misconception","count":null,"maxCount":null,"percent":67,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignmentCopiesObject"},{"lang":"Python","name":"AssignmentCopiesObject"},{"lang":"JavaScript","name":"AssignmentCopiesObject"}],"note":null},{"id":"StructByRef","name":"Data structures might refer to variables by their references","observations":[{"kind":"Percentage","measure":"Learners hold misconception","count":null,"maxCount":null,"percent":24,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null},{"id":"StructsCopyStructs","name":"Storing data structures into data structures makes copies","observations":[{"kind":"Percentage","measure":"Learners hold misconception","count":null,"maxCount":null,"percent":6,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"AssignmentCopiesObject"},{"lang":"Python","name":"AssignmentCopiesObject"},{"lang":"JavaScript","name":"AssignmentCopiesObject"}],"note":null},{"id":"Lazy","name":"Expressions are only evaluated when their values are needed","observations":[{"kind":"Percentage","measure":"Learners hold misconception","count":null,"maxCount":null,"percent":57,"counts":null,"levelLabels":null,"value":null,"maxValue":null,"maxLabel":null,"minValue":null,"minLabel":null,"category":null,"categoryDescription":null}],"plMisconceptions":[{"lang":"Java","name":"VariablesHoldExpressions"},{"lang":"Python","name":"VariablesHoldExpressions"}],"note":null}]}]},"fields":{"slug":"/references/luIdentifyingCorrectingProgramming2024/","citationKey":"luIdentifyingCorrectingProgramming2024"}}}]}},"pageContext":{"citationKey":"rodrigoAnAnalysisOfJavaProgramming2013"}},
    "staticQueryHashes": ["3649515864","4169798128"]}