User-centricity and usability are a premise of digitalization, a current trend for business model innovation based on advanced digital technologies. The article addresses a gap in the literature, in which descriptions of the cases of updating university curricula in usability are lacking. This gap also exists in the practice. The study uses the example of a project for revising the content of usability courses at the University of Turku as a case. The research objective is to explore an integrative approach to usability education. For this, we consider the data collected via interviews with the faculty teaching usability subjects. Thematic analysis is applied to examine the interview outcomes. Recommendations as to updating usability curricula are provided.
Prior programming knowledge of students has a major impact on introductory programming courses. Those with prior experience often seem to breeze through the course. Those without prior experience see others breeze through the course and disengage from the material or drop out. The purpose of this study is to demonstrate that novice student programming behavior can be modeled as a Markov process. The resulting transition matrix can then be used in machine learning algorithms to create clusters of similarly behaving students. We describe in detail the state machine used in the Markov process and how to compute the transition matrix. We compute the transition matrix for 665 students and cluster them using the k-means clustering algorithm. We choose the number of cluster to be three based on analysis of the dataset. We show that the created clusters have statistically different means for student prior knowledge in programming, when measured on a Likert scale of 1-5.
In a previous publication we examined the connections between high-school computer science (CS) and computing higher education. The results were promising—students who were exposed to computing in high school were more likely to take one of the computing disciplines. However, these correlations were not necessarily causal. Possibly those students who took CS courses, and especially high-level CS courses in high school, were already a priori inclined to pursue computing education. This uncertainty led us to pursue the current research. We aimed at finding those factors that induced students to choose CS at high school and later at higher-education institutes. We present quantitative findings obtained from analyzing freshmen computing students' responses to a designated questionnaire. The findings show that not only did high-school CS studies have a major impact on students’ choice whether to study computing in higher education—it may have also improved their view of the discipline.
This paper focuses on the analysis of Bebras Challenge tasks to find Informatics tasks that develop abstract thinking. Our study seeks to find which Bebras tasks develop abstraction and in what way. We analysed hundreds of tasks from the Czech contest to identify those tasks requiring participants to abstract directly or use abstract structures. Results show that an agreement among experts on stating which task is focused on abstraction is at a moderate level. We discovered that tasks focused on abstraction occur four to five times less frequently in sets of contest tasks than algorithmic tasks. Our findings proved that abstract tasks results compared with algorithmic ones did not differ in neither age nor gender group of contestants.
Concurrency is often perceived as difficult by students. One reason for this may be due to the fact that abstractions used in concurrent programs leave more situations undefined compared to sequential programs (e.g., in what order statements are executed), which makes it harder to create a proper mental model of the execution environment. Students who aim to explore the abstractions through testing are further hindered by the non-determinism of concurrent programs since even incorrect programs may seem to work properly most of the time. In this paper we aim to explore how students’ understanding these abstractions by examining 137 solutions to two concurrency questions given on the final exam in two years of an introductory concurrency course. To highlight problematic areas of these abstractions, we present alternative abstractions under which each incorrect solution would be correct.
Introductory programming courses (CS1) are difficult for novices. Inspired by Problem solving followed by instruction and Productive Failure approaches, we define an original “necessity-driven” learning design. Students are put in an apparently well-known situation, but this time they miss an essential ingredient (the target concept) to solve the problem. Then, struggling to solve it, they experience the necessity of that concept. A direct instruction phase follows. Finally, students return to the problem with the necessary knowledge to solve it. In a typical CS1 learning path, we recognise a challenging “rollercoaster of abstraction”. We provide examples of learning sequences designed with our approach to support students when the abstraction changes (both upward and downward) inside the programming language, for example, when a new construct (and the related syntactical, conceptual, and strategic knowledge) is introduced. Also, we discuss the benefits of our design in light of Informatics education literature.
When we “think like a computer scientist,” we are able to systematically solve problems in different fields, create software applications that support various needs, and design artefacts that model complex systems. Abstraction is a soft skill embedded in all those endeavours, being a main cornerstone of computational thinking. Our overview of abstraction is intended to be not so much systematic as thought provoking, inviting the reader to (re)think abstraction from different – and perhaps unusual – perspectives. After presenting a range of its characterisations, we will explore abstraction from a cognitive point of view. Then we will discuss the role of abstraction in a range of computer science areas, including whether and how abstraction is taught. Although it is impossible to capture the essence of abstraction in one sentence, one section or a single paper, we hope our insights into abstraction may help computer science educators to better understand, model and even dare to teach abstraction skills.
Controlling complexity through the use of abstractions is a critical part of problem solving in programming. Thus, becoming proficient with procedural and data abstraction through the use of user-defined functions is important. Properly using functions for abstraction involves a number of other core concepts, such as parameter passing, scope and references, which are known to be difficult. Therefore, this paper aims to study students’ proficiency with these core concepts, and students’ ability to apply procedural and data abstraction to solve problems. We collected data from two years of an introductory Python course, both from a questionnaire and from two lab assignments. The data shows that students had difficulties with the core concepts, and a number of issues solving problems with abstraction. We also investigate the impact of using a visualization tool when teaching the core concepts.
The notion of algorithm may be perceived in different levels of abstraction. In the lower levels it is an operational set of instructions. In higher levels it may be viewed as an object with properties, solving a problem with characteristics. Novices mostly relate to the lower levels. Yet, higher levels are very relevant for them as well. We unfold the importance of higher level abstractions for novices, by demonstrating the role of declarative observations of algorithmic problems, and the benefit of developing awareness of such observations in algorithmic problem solving. This is shown in a two-stage study, which first reveals the unfortunate lack of declarative observations, and then displays comparative results of experimental and control groups, which stems from different awareness and competence with declarative observations.
Computer science students often evaluate the behavior of the code they write by running it on specific inputs and studying the outputs, and then apply their comprehension to a more general understanding of the code. While this is a good starting point in the student’s career, successful graduates must be able to reason analytically about the code they create or encounter. They must be able to reason about the behavior of the code on arbitrary inputs, without running the code. Abstraction is central for such reasoning.
In our quest to help students learn to reason abstractly and develop logically correct code, we have developed tools that rely on a verification engine. Code involves assignment, conditional, and loop statements, along with objects and operations. Reasoning activities involve symbolic reasoning with simple assertions and design-by-contract assertions such as pre-and post-conditions as well as loop invariants with data abstractions. Students progress from tracing and reading code to the design and implementation of code, all relying on abstraction for verification. This paper reports some key results and findings from associated studies spanning several years.