This paper explores the relationship between student performance on online programming exercises completed during semester with subsequent student performance on a final exam. We introduce an approach that combines whether or not a student produced a correct solution to an online exercise with information on the number of attempts at the exercise submitted by the student. We use data collected from students in an introductory Java course to assess the value of this approach. We compare the approach that utilizes the number of attempts to an approach that simply considers whether or not a student produced a correct solution to each exercise. We found that the results for the method that utilizes the number of attempts correlates better with performance on a final exam.

In traditional programming courses, students have usually been at least partly graded using pen and paper exams. One of the problems related to such exams is that they only partially connect to the practice conducted within such courses. Testing students in a more practical environment has been constrained due to the limited resources that are needed, for example, for authentication.

We conducted two studies on the effect of visual reward mechanisms for increasing engagement with an online learning material. In the first study, we studied the effect of showing cat pictures as a reward to correct and incorrect answers to multiple choice questions, and in the second study, we created an illusion of progress using a progress bar that showed step-wise increments as students answered to the questions. Our results show the use of cat pictures as a visual reward mechanism does not significantly increase students' engagement with learning materials. At the same time, students who were shown progress bars had a statistically significant increase in the quantity of answers -- on average 88% more answers per day. However, our results also indicate that this effect declines over time, meaning that students catch up to the illusion.

The computing education community has studied extensively the errors of novice programmers. In contrast, little attention has been given to student's mistake in writing SQL statements. This paper represents the first large scale quantitative analysis of the student's syntactic mistakes in writing different types of SQL queries. Over 160 thousand snapshots of SQL queries were collected from over 2000 students across eight years. We describe the most common types of syntactic errors that students make. We also describe our development of an automatic classifier with an overall accuracy of 0.78 for predicting student performance in writing SQL queries.

Studies on retention and success in introductory programming course have suggested that previous programming experience contributes to students' course outcomes. If such background information could be automatically distilled from students' working process, additional guidance and support mechanisms could be provided even to those, who do not wish to disclose such information. In this study, we explore methods for automatically distinguishing novice programmers from more experienced programmers using fine-grained source code snapshot data. We approach the issue by partially replicating a previous study that used students' keystroke latencies as a proxy to introductory programming course outcomes, and follow this by an exploration of machine learning methods to separate those students with little to no previous programming experience from those with more experience. Our results confirm that students' keystroke latencies can be used as a metric for measuring course outcomes. At the same time, our results show that students programming experience can be identified to some extent from keystroke latency data, which means that such data has potential as a source of information for customizing the students' learning experience.

Methods for automatically identifying students in need of assistance have been studied for decades. Initially, the work was based on somewhat static factors such as students' educational background and results from various questionnaires, while more recently, constantly accumulating data such as progress with course assignments and behavior in lectures has gained attention. We contribute to this work with results on early detection of students in need of assistance, and provide a starting point for using machine learning techniques on naturally accumulating programming process data.

A small number of recent studies have suggested that learning is enhanced when the illustrations in instructional materials are designed to appeal to the learners' emotions through the use of color and the personification of key elements. We sought to replicate this emotional design effect in the context of introductory object-oriented programming (OOP). In this preliminary study, a group of freshmen studied a text on objects which was illustrated using anthropomorphic graphics while a control group had access to abstract graphics. We found no significant difference in the groups' scores on a comprehension post-test, but the experimental group spent substantially less time on the task than the control group. Among those participants who had no prior programming experience, the materials inspired by emotional design were perceived as less intelligible and appealing and led to lower self-reported concentration levels. Although this result does not match the pattern of results from earlier studies, it shows that the choice of illustrations in learning materials matters and calls for more research that addresses the limitations of this preliminary study.

This study investigates chat room data from a massive open online course (MOOC) that has been organized several times since January 2012. What makes the organization unique is that the chat room has always remained the same, allowing past participants to mingle with the new course takers. Participants who have previously attended the course have started to support the novices, voluntarily taking the role of mentors, while at the same time also learning themselves. Two and a half years of chat logs and interviews show that it is possible that a community consisting of previous and current participants emerges naturally. Furthermore, there are plenty of students that unconditionally help others, even when they themselves no longer attend the course. Our observations suggest that communities of practice emerge naturally around the chat rooms of MOOCs.

This article describes an experimental course where students developed Internet of Things device prototypes to improve the upkeep of an urban rooftop greenhouse. With the help of a problem-based learning approach, students were first familiarized with their new learning environment and encouraged to find issues that could be improved as a meaningful personal learning experience. A project-based learning approach was then used to develop innovative solutions while validating their relevance in collaboration with gardeners that were taking care of the greenhouse. As a result, a number of practical applications for monitoring the state of the greenhouse were developed along with new practices for its maintenance. As participants were given the freedom to choose both the topic and technologies to work with, the course provided a learning experience that was tailored to suit personal interests and competences. Having the common background story allowed students to practice teamwork skills and collaborative software engineering in the context of the emerging topic of Internet of Things.

One approach for helping students learn to program is the use of self-explanation assignments. In these assignments, students explain instructional materials using domain knowledge covered in the course. In this work, we describe a randomized experiment where students in an introductory programming course were given two kinds of self-explanation assignments. One randomly selected group worked on self-explanation assignments with supporting questions while the alternate group had the same self-explanation questions but no additional supporting exercises. The combined groups performed better on comparable test questions than students from the previous year, who did not use self-explanation questions. The group with supporting questions performed better than the group with no additional support. Based on our results and previous research on self explanation, we argue that embedding self-explanation questions into programming material is beneficial for students. Moreover, further gains are achieved from supporting questions that help focus their explanations.

The Finnish national school curriculum, effective from 2004, does not include any topics related to Computer Science (CS). To alleviate the problem that school students are not able to study CS-related topics, the Department of Computer Science at the University of Helsinki prepared a completely online course that is open to pupils and students in all schools in Finland. The course is a Massive Open Online Course (MOOC), as the attendance scales without an upper bound. Schools in Finland have offered the MOOC as an elective CS course for their students and granted formal school credits for completing (parts of) it. Since our MOOC is exactly the same programming course as our university-level CS1 course, we are able to use the MOOC also as a long-lasting entrance exam to the CS BSc and MSc degrees. After two spring semesters of operation, we have observed that there are school students dispersed around Finland who are ready and willing to take on a challenging programming course online, and bridging the MOOC to a full study right makes a strong incentive to keep working on the programming assignments, even without traditional teaching.

Decades of effort has been put into decreasing the high failure rates of introductory programming courses. Whilst numerous studies suggest approaches that provide effective means of teaching programming, to date, no study has attempted to quantitatively compare the impact that different approaches have had on the pass rates of programming courses. In this article, we report the results of a systematic review on articles describing introductory programming teaching approaches, and provide an analysis of the effect that various interventions can have on the pass rates of introductory programming courses. A total of 60 pre-intervention and post-intervention pass rates, describing thirteen different teaching approaches were extracted from relevant articles and analyzed. The results showed that on average, teaching interventions can improve programming pass rates by nearly one third when compared to a traditional lecture and lab based approach.

No abstract available.

A large body of systems that gather data on students' programming process exists, and with the increase of massive open online courses in programming, the amount of gathered data is growing even at a higher rate. A common issue for data analysis is the lack of common tools for visualizing source code snapshots. We have created a browser-side snapshot analysis tool called CodeBrowser that provides a clean REST API that anyone can integrate their snapshot data into. In this article, we describe CodeBrowser and as an example, discuss how it has been used to seek differences between novice programmers that have passed (n=10) or failed (n=10) an introductory programming course.

A great CS assignment is a delight to all, but the path to one can be most roundabout. Many CS students have had their characters built up on assignments that worked better as an idea than as an actual assignment. Assignments are hard to come up with, yet they are the key to student learning. The Nifty Assignments special session is all about promoting and sharing the ideas and ready-to-use materials of successful assignments.

Software engineering has evolved greatly during the last couple of decades. The methodologies for organizing software engineering projects, as well as the technologies for building software have changed dramatically. However, this evolution is seldom reflected in the software engineering-related education provided by research-oriented computer science departments. Many traditional research-oriented universities continue to teach using the “talking head”-approach, where students are expected to absorb information out of the atmosphere in the lecture halls. In this paper, we describe our work towards “webifying” a software engineering curriculum, where learning by doing plays a key role.

To prepare students for real-life software engineering projects, many higher-education institutions offer courses that simulate working life to varying degrees. As software engineering requires not only technical, but also inter- and intrapersonal skills, these skills should also be assessed. Assessing soft skills is challenging, especially when project-based and experiential learning are the primary pedagogical approaches. Previous work suggests that including students in the assessment process can yield a more complete picture of student performance. This paper presents experiences with developing and using a peer assessment framework that provides a 360-degree view on students' project performance. Our framework has been explicitly constructed to accommodate and evaluate tacit skills that are relevant in agile software development. The framework has been evaluated with 18 bachelors- and 11 masters-level capstone projects, totaling 176 students working in self-organized teams. We found that the framework eases teacher workload and allows a more thorough assessment of students' skills. We suggest including self- and peer assessment into software capstone projects alongside other, more traditional schemes like productivity metrics, and discuss challenges and opportunities in defining learning goals for tacit and social skills.

We argue that the first undergraduate courses are the most important ones on the student's path towards becoming a computer scientist. Therefore, during 2010-2012, we have exercised extensive effort in order to improve the first-semester Computer Science (CS) courses. We have been able to use a learning-by-doing approach called the Extreme Apprenticeship (XA) method accompanied by personal advising even for courses with hundreds of students. We claim that when high demands are met with sufficient support, students learn valuable programming skills that become a foundation that carries them in their further CS courses. In this paper, we analyze how the effects of a three-year effort of renovating our introductory programming courses propagate to further studies. Compared to the control cohorts of 2007-2009, we observe a carry-on-effect caused by the XA method in student success that is visible in the per-student average accumulation of credits after 7 and 13 months after the start of studies. In addition, we can see the effect propagating to mandatory subsequent courses, even without the XA method.

As the amount of data, facilities, and tools for understanding students' programming process are improving, the time is ripe for analyzing students' actual programming process. In our current work we are investigating how students' behavior during her programming process (e.g. eagerness to start working on freshly released exercises, following best programming practises) affects the course outcome. We purposefully utilize only data gathered automatically using snapshots from the students' programming process, and do not gather any additional background information. Currently, we are able to predict whether the student is a high-performer, passes the course, or fails the course with a 78%accuracy.

Although programming is the basis for many CS/IT-programmes, it is still often being taught using methods from the pre-book era. This paper describes a transition from traditional lecture-based approach to using the Extreme Apprenticeship method with an automated assessment service in teaching programming. The transition has led to a situation, where the course instructors feel their work as more meaningful and have more time for students. A comparison between a traditional lecture-based approach and the Extreme Apprenticeship method over the last 20 course instances shows a statistically significant improvement in the students' pass-rates, as well as in the amount of students that complete exercises during the final weeks of a programming course.

Incorporating students to participate as teaching assistants in our CS1 as early as during their second semester has started a snowball effect, in which more and more students want to be a part of the experience. We allow students to contribute and take responsibility in a context they see as meaningful for teaching. The students-as-teachers approach means that they are mentored by senior teachers in the actual teaching context, which guarantees enough peer and faculty support for students undertaking the task. A significant percentage of our students (ca. 20%) participate as teachers. This has brought us several benefits: (1) new students are welcomed to the learning community by other students as representatives of the institution, not just student organizations, (2) students understand and undertake the responsibility of being a teacher early, and (3) a massive number of eager TAs.

As programming is the basis of many CS courses, meaningful activities in supporting students on their journey towards being better programmers is a matter of utmost importance. Programming is not only about learning simple syntax constructs and their applications, but about honing practical problem-solving skills in meaningful contexts. In this article, we describe our current work on an automated assessment system called Test My Code (TMC), which is one of the feedback and support mechanisms that we use in our programming courses. TMC is an assessment service that (1) enables building of scaffolding into programming exercises; (2) retrieves and updates tasks into the students' programming environment as students work on them, and (3) causes no additional overhead to students' programming process. Instructors benefit from TMC as it can be used to perform code reviews, and collect and send feedback even on fully on-line courses.

Data Structures (CS2) courses and course books do not usually put much emphasis in the process of how a data structure is engineered or invented. Instead, algorithms are readily given, and the main focus is in the mathematical complexity analysis of the algorithms. We present an alternative approach on presenting data structures using worked examples, i.e., by explicitly displaying the process that leads to the invention and creation of a data stucture and its algorithms. Our approach is heavily backed up by some of the best programming practices advocated by the Agile and Software Craftsmanship communities. It brings the often mathematically oriented CS2 course closer to modern software engineering and practical problem solving, without a need for compromise in proofs and analysis.

Programming is a craft that can be efficiently learned from people who already master it. Our previous work introduced a teaching method we call Extreme Apprenticeship (XA), an extension to the cognitive apprenticeship model. XA is based on a set of values that emphasize doing and best programming practices, together with continuous feedback between the master and the apprentice. Most importantly, XA is individual instruction that can be applied even in large courses. Our initial experiments (n = 67 and 44) resulted in a significant increase in student achievement level compared to previous courses. In this paper, we reinforce the validity of XA by larger samples (n = 192 and 147) and a different lecturer. The results were similarly successful and show that the application of XA can easily suffer if the core values are not fully adhered to.

Learning a craft like programming is efficient when novices learn from people who already master the craft. In this paper we define Extreme Apprenticeship, an extension to the cognitive apprenticeship model. Our model is based on a set of values and practices that emphasize learning by doing together with continuous feedback as the most efficient means for learning. We show how the method was applied to a CS I programming course. Application of the method resulted in a significant decrease in the dropout rates in comparison with the previous traditionally conducted course instances.

This video illustrates the notion of the k-order α-hull of a planar point set - a generalization of the α-hull and the k-hull.

OSINT (Open-Source Intelligence) tool is constructed for Frontex to automate the process of extracting structured knowledge from on-line news articles on border-security related event at the EU borders and in the related third countries. Incidents and developments are relevant context for illegal migration. European Commission has identified and acknowledged the need for strengthening capabilities for tracking the security situation.

This video illustrates an algorithm for computing a maximum number of disjoint paths for unit disks moving among a set of dynamic obstacles in the plane. The problem is motivated by applications in air traffic management: aircraft must be routed while avoiding no-fly zones and weather constraints and while maintaining at least a specified horizontal separation distance between themselves. Given a polygonal domain with moving obstacles, our goal is to determine the maximum number of unit disks (aircraft with safety zones) that can be routed safely through the domain, entering/exiting through specified edges of the domain.