|Exposing The Most Frequent Mistakes In Programming|
|Written by Nikos Vaggalis|
|Monday, 09 May 2016|
Page 2 of 2
The current research, reported in "37 Million Compilations: Investigating Novice Programming Mistakes in Large-Scale
To arrive at valuable conclusions, a large data set should exist, and Blackbox had exactly that: participation of 250,000 Java programming novices from institutions all over the world and source code from 37 million compilations.
After processing that huge amount of data, the list with the most frequent mistakes was compiled (in descending order, thus error C is the most frequent) :
But that's not all. Further insights conclude that:
"Syntax errors show a small peak at the beginning of
The Type curve is interesting as it shows a sudden rise and drop towards the end of the academic year, possibly due to introducing advance types for students.
In contrast, Semantic mistakes show a decrease of the time needed to ﬁx over the course of the year, Type mistakes
The only interpretation we can offer is that with the increase of topics introduced to students, moving from primitive types to generic types and inheritance, students tend to make more mistakes between these ‘more diffcult’ types"
So as a side-product of the research's findings, can we reach a conclusion as far as typing is concerned? Are dynamic languages easier to work with, since they require no type information at compile time as automatic type coercion is done at runtime?
In other words, is dynamic typing better since you avoid the Type related mistakes from happening?
It certainly sounds so. Further proof comes from another study, "An Empirical Investigation into Programming Language Syntax".
Its findings were that :
"Our results may also have implications for instructors and students in regards to the use of static type systems, because of the observed difficulty novices have with static type annotations.
At first it might appear that dynamic typing helps novices but further down we find that :
"We suspect that some might believe our results imply dynamic typing is better for novices, but we find this explanation implausible.....Thus, claiming that dynamic typing is
Instead a system utilizing type inference is the way to go :
"We have derived a type inference system that removes most type annotations inside of methods, keeps annotations in method declarations, and keeps static type checking itself. More study is needed, but compromises like this may afford ease of use for all."
All these conclusions are a product of data collection done through a single IDE. Imagine an initiative that collected data from the many hundreds of MOOC's out there. How would that improve the experience of programming and evolve educational material?
Utilization of such data in the educational industry would lead to big gains almost from day one.
Altadmri, A. and Brown, N. (2015). 37 Million Compilations: Investigating Novice Programming Mistakes in Large-Scale Student Data. in: SIGCSE '15: The 46th SIGCSE technical symposium on Computer science education. ACM, pp. 522-527.
Brown, N. et al. (2014). Blackbox: A Large Scale Repository of Novice Programmers’ Activity. in: The 45th SIGCSE technical symposium on computer science education (SIGCSE 2014). ACM.
Andreas Stefik and Susanna Siebert. 2013. An Empirical Investigation into Programming Language Syntax. ACM Transactions on Computing Education 13, 4, Article 19 (November 2013), 40 pages.
Beginners' 10 most common Java programming mistakes revealed by Big Data
Blackbox programs written in Haskell
To be informed about new articles on I Programmer, sign up for our weekly newsletter,subscribe to the RSS feed and follow us on, Twitter, Facebook, Google+ or Linkedin.
or email your comment to: firstname.lastname@example.org
|Last Updated ( Monday, 09 May 2016 )|