While most student code is assessed for correctness and functionality, recent work has looked at extending automatic assessment to include quality aspects. In software engineering code reviews help developers to increase the quality of a project by identifying and cleaning poor structures - commonly referred to as code smells. Despite the availability of professional tools, evaluating the quality of small programs at CS1 level is quite different from evaluating a complex software system. Thus, identifying meaningful quality criteria for small programs written by novices and either adapting current tools or designing new ones for that purpose are topics worth being investigated. The present work contributes to this aim by analysing the code produced by CS1 students from three different perspectives: (i) inspecting the feedback of automated tools - Hyperstyle and Pylint; (ii) matching the smells addressed by a set of refactoring rules; (iii) devising and using a manual rubric. A comparative analysis indeed highlights strengths and weaknesses of these approaches. Overall, automatic quality feedback needs to be complemented with classroom instruction to manually detect code issues and decide if they need refactoring. Additionally, such review activities have the potential to develop code comprehension by engaging novice programmers to reflect on their own code.

Whilst most undergraduate students eventually produce functionally correct code, they often disregard their code style and overall quality when it is not graded. As reported by the literature, quality defects affect both code structure and code style, and these issues seem to persist even in later years. This paper reports on the potential of a low-cost intervention that directed CS2 students to revise and refactor their code, with a specific focus on code structure, by resorting to a range of online refactoring resources.

Characterising code quality is a challenge that was addressed by Börstler et al. 's working group in 2017. As emerged from their study, educators, developers and students have different perceptions of the manifold aspects involved, and a major conclusion of that WG was that "code quality should be discussed more thoroughly in educational programs" [2, p. 70]. However, the lack of materials and the time constraints have slowed down progress in that regard.

This working group concerns the adoption of computing education (CE) in undergraduate computer science (CS) programmes. Such adoption requires both arguments sufficient to persuade our departmental colleagues and our education committees, and also curricular outlines to assist our colleagues in delivery. The goal of the group is to develop examples of both arguments and curricular outlines, drawing on any prior experience available.

Programming plays a paramount role in many educational policies and initiatives. However, the current focus on coding skills poses a risk of giving pupils an over simplistic and impoverished idea of what programming means and involves. Their experiences would be much more significant if learning were aimed at understanding the richness of the nature of programs. In fact, programs are strange creatures that escape simple definitions. They are real, in that they affect our real lives; they are abstract, in that they process abstract entities; and they are concrete, in that they take up space in digital devices memory, and can be copied, transferred, corrupted. Thus, understanding the multifaceted nature of programs is crucial knowledge for all citizens of the digital era, and a fundamental component of such an understanding is getting a sense of how programs are created and work (i.e., the programming process). To the best of our knowledge, there is no Nature of Programs framework (e.g., a set of statements that describe what the nature of programs is), that teachers and policy makers can use to shape their practice and targets. The goal of the WG is developing such a framework, by collecting and organizing contributions from CER, CS experts, and educators.

Learning transfer refers to the ability to correctly apply learned skills, knowledge and behaviors to new situations or contexts. This paper explores novice programmers' transfer through the analysis of two related coding tasks completed by CS1 students as part of their assessment. The first task was a take-home practical and the second task was a lab practical exam; both tasks requested the implementation of a C function with an integer parameter from which the digits are to be extracted and operated on. The solution set generated from each task by a cohort of 255 CS1 students has been explored and classified in order to determine the extent of transfer from the practice task to the later assessment task.

Novice programmers should develop program comprehension skills as they learn to code so that they are able both to read and reason about code created by others, and to reflect on their code when writing, debugging or extending it. This work takes a little-explored perspective on the comprehension of small programs by asking students to decide if two code segments are equivalent or not in terms of carrying out the same computation. A variation of Euclid's algorithm, that extends the greatest common divisor calculation to more than two numbers, was chosen for this work, as it has an adequate level of complexity and its semantics are not obvious. Four program transformations of the original code were developed: two transformations were equivalent and two were not. 73.5% of students were able to identify correctly the four options and 75.5% provided good insights on the equivalent program flow to justify their choices. The overall task has a SOLO mean of 3.19, which indicates code equivalence is a suitable and approachable task to analyse program execution at novice level. In addition, the data analysis suggests that students' code-reading abilities beyond basic tracing may be generally underestimated and we should investigate how to bridge the potential gap between reasoning about program execution and extracting its purpose.

This working group asserts that Program Comprehension (PC) plays a critical part in the writing process. For example, this abstract is written from a basic draft that we have edited and revised until it clearly presents our idea. Similarly, a program is written in an incremental manner, with each step being tested, debugged and extended until the program achieves its goal. Novice programmers should develop their program comprehension as they learn to code, so that they are able to read and reason about code while they are writing it. To foster such competencies our group has identified two main goals: (1) to collect and define learning activities that explicitly cover key components of program comprehension and (2) to define possible learning trajectories that will guide teachers using those learning activities in their CS0/CS1 or K-12 courses.

Students of introductory programming courses are expected to develop higher-order thinking skills to inspect, understand and modify code. However, although novices can correctly write small programs, they appear to lack a more abstract, comprehensive grasp of basic constructs, such as conceiving the overall effect of alternative conditional flows. This work takes a little-explored perspective on the comprehension of tiny programs by asking students to reason about reversing conditionals in either an imperative or a functional context. More specifically, besides deciding if the given constructs can be reversed, students had to justify their choice by writing a reversing program or by providing suitable counterexamples. The students' answers to four reversibility questions have been analysed through the lens of the SOLO taxonomy. 45% of students correctly identified the reversibility for the four code items; furthermore, more than 50% of each cohort were able to provide correct justifications for at least three of their four answers. Most incorrect answers were due to failures to consider border cases or to edit the conditional expressions appropriately to reverse the construct. Differences in comprehension between functional and imperative languages are explored indicating the explicit else paths of the functional examples facilitate comprehension compared with the implicit else (no update) of its imperative counterpart.

We want undergraduate students to develop higher-order thinking skills that enable them to master program behaviour. Nonetheless, many students of both introductory and advanced programming courses appear to struggle with the abstraction required for this purpose. In particular, a recent think-aloud study showed a group of students were able to reason about and reverse the effect of assignments and vector updates, but most of them failed when asked to reverse a seemingly simple conditional statement.

Current CS1 learning outcomes are relatively general, specifying tasks such as designing, implementing, testing and debugging programs that use some fundamental programming constructs. These outcomes impact what we teach, our expectations, and our assessments. Although prior work has demonstrated the utility of single concept assessments, most assessments used in formal examinations combine numerous heterogeneous concepts, resulting in complex and difficult tasks.

There is general consensus that recursion is difficult to learn, which may be meant to imply that novice students are more at ease with iteration --- probably a widespread perception of students themselves. However, three years of investigation in a context where recursion is introduced earlier than iteration, as well as control experiments for a standard imperative-first introduction to programming, have provided no evidence that students make more progress with iteration than they do with recursion. More specifically, by means of a pair of questionnaires devised for this purpose, two research questions have been addressed. First, do the students who learned recursion before iteration actually exhibit a stronger ability to deal with the latter? Second, do the students of the imperative-first path master iteration better than those of the recursion-earlier path?

Despite a general consensus on the difficulties faced to master recursion, a two-year investigation on the achievements in a 'functional-first' introductory course does not corroborate the hypothesis that students are more at ease with iteration than they are with recursion.

We have tried to introduce some ideas and way of thinking of computer science through a set of extra-curricular activities on nursery rhymes. In this paper we discuss our experience in an Italian middle school. The chosen subject is naturally connected to what the pupils see, or listen to, in the primary school as well as in their home. Starting from this material which is familiar to them, the pupils are guided to explore the "computational paradigm". This is accomplished through gradual steps, where they are solicited to observe, to analyze, to devise models and, eventually, to develop simple programs in Logo. Our work is an attempt to suggest a different perspective on computation, since most of the opportunities for the pupils to interact with the new technologies tend to reinforce a view that relegates all the computing sphere to a merely instrumental role.

In this paper I will discuss an investigation intended to address the learning of recursion in a multidimensional perspective, where the dimensions correspond to different types of competence relevant to programming. One such dimension is the understanding of the computation model, that I have assessed under the methodology proposed by Goetschi et al. (2003). Moreover, I have tried to analyze and correlate other learning dimensions, such as the ability to establish relations in the problem domain, to deal with recursive structures, as well as to develop basic abstraction skills. One of my objectives is indeed to gain a better understanding of the major sources of difficulties that students face. In essence, my investigation lends further support to previous related findings on mental models. However, a consistent model of recursive computations, although implied by the ability to use recursion in problem-solving, does not seem to be sufficient for the achievement of higher-level skills.

The work outlined here was inspired by a related one, where the authors analyze the mental models of recursion by looking at how students trace simple recursive computations. Besides trying to understand if their results generalize to a different context, I was interested to see the correlations between the mental models of the computation process and the ability to establish recursive relationships in the problem domain. My investigation essentially lends further support to those above findings. However, a consistent mental model of recursive computations, although implied by the ability to use recursion in problem-solving, does not seem to be suffcient for the achievement of this higher-level skill.

The Italian Association of Automatic Computing (AICA) promotes the introduction of academic courses on the computing history. Also the University of Udine participates in this project by offering an elective course in the CS and IT programs. After the first two years of this new experience, we attempt to outline what is emerging from the analysis of the students' answers to a couple of specifically designed questionnaires and to the examination tests. A major point of interest is that the course helps us to get some insight on our students' general background and attitude toward culture. In particular, the first observations seem to indicate that they are rather curious about the technological artifacts, but come with a poor historical picture and then have difficulty putting science and technology in a historical perspective. Although our analysis reveals some positive trends, it is not easy to assess the course effectiveness in this respect because of the lack of suitable benchmarks.

Different coherence dimensions can be considered to improve the performances of an algorithm for computing collision translations of pairs of convex polyhedra. The algorithm's peculiar approach, based on convex minimization, is well suited to work without initialization and also endowed with an inherently embedded mechanism to exploit spatial coherence in a broader sense than other related approaches usually do. After a brief outline of the algorithm, we summarize the outcomes of several numerical experiments meant to explore extensively the incremental behavior of the algorithm while controlling the coherence parameters. In order to assess the efficacy and the potential of the approach, the performances are also discussed in the light of the results on H-Walk, an algorithm specifically designed to adapt to variable coherence.

The subject of this paper is an asymptotically fast and incremental algorithm for computing collision translations of convex polyhedra, where the problem at hand is reduced to determining collision translations of pairs of planar sections and minimizing a bivariate convex function. There are two main reasons, in our view, why the algorithm is worth consideration. On the one hand, the addressed proximity measure, namely collision translation, is not as widely studied as distance. On the other, its peculiar computation strategy may be interesting in itself, being well suited to work without initialization and also endowed with an inherently embedded mechanism to exploit spatial coherence. After outlining the main ideas of this novel approach and providing an estimation of the computational costs, we summarize a broad set of numerical experiments meant to explore extensively the behavior of the algorithm, both without and with initialization. Finally, in order to assess the efficacy and the potential of the approach under analysis, the attained performances are contrasted with those of other popular algorithms designed to compute distances between polyhedra. A thorough comparison of the reported query times and, more significantly, of the corresponding trends shows that the behavior of the collision translation algorithm is quite interesting, especially when used without initialization or under variable coherence, which should encourage further work on this approach.

This paper presents a comparative analysis relative to the experimental performances of an asymptotically fast and incremental algorithm, recently developed to compute collision translations for pairs of convex polyhedra. The algorithm may be worth considering because it solves a proximity problem which is less widely addressed than distance, as well as because of its peculiar computation strategy, well suited to work without initialization, but also endowed with an inherently embedded mechanism to exploit spatial coherence. Numerical data characterizing the behavior of the algorithm with respect to the complexity of the polyhedra have already been discussed elsewhere, thus here the main focus is on contrasting its performances with those of two popular algorithms designed to compute distances between polyhedra. Although the considered "yardsticks" answer different proximity queries, and although one of the techniques is meant to deal with general polyhedra, the results presented in this paper should help to assess the efficacy and potential of the approach under analysis. All the three algorithms, indeed, share the same kind of application context; moreover, on the basis of the asymptotic bounds discussed in the literature, distances and collision translations require similar computational efforts. A thorough comparison of the reported query times and, more significantly, of the corresponding trends seems to show that the behavior of the novel algorithm is quite interesting, especially when used without initialization, what should encourage further work on its peculiar approach

Considering a historical perspective may be not only, in Knuth's witty words [?], "one of the ways to help make computer science respectable," but also a valuable tool for education purposes. After outlining the main reasons for teaching the history of computing, in this paper we present a virtual museum on the subject, addressed to Italian students, developed in a cooperative project engaging both university and school teachers. It is meant first of all as an opportunity to experiment a learning environment suitable to explore the cultural roots of computer science, especially in the school ages. We are now planning classroom experiences to assess this tool, as well as proposing it in a curricular course on the history of computer science for training secondary school teachers.

The paper presents a fast algorithm to compute collision translations for pairs of convex polyhedra with some interesting features. From a theoretical viewpoint, besides the novelty of the approach, the polylog asymptotic trend in the average case is as good as that of the best algorithms proposed to solve the similar problems. On the other hand, the measured performances to detect possible collisions from scratch are satisfactory, and this is especially true in cases where the bodies do not collide. However, the most peculiar feature is a simple and flexible mechanism to exploit spatial coherence in a continuous range, which distinguishes this algorithm from all the other proposals we know. Furthermore, the nature of the approach is such that the self-tuning capability is attained at negligible additional costs even for unrelated collision tests. After a brief outline of the main ideas characterizing the approach, a set of numerical results are summarized. The proposed algorithm may be appropriate to plan collision-free paths, both online and off-line, on the basis of fine-grain descriptions of the objects in the workspace.

The subject of the paper is a fast algorithm for detecting collisions of two convex polyhedra translating in space. A major feature is the novelty of the approach: collision detection for two convex bodies is reduced to collision detection for pairs of planar sections and minimization of a bivariate convex function; furthermore, most of the subproblems are solved using two-dimensional geometry. As proved by previous theoretical work, on this basis it is possible to design an algorithm, which runs in O(log/sup 2/n) time in the average and O(log/sup 3/n) in the worst case, where n is the total number of vertices. Here the focus is on a more practical version of the algorithm, which is particularly suited to plan collision-free paths on the basis of fine-grain descriptions of the objects in the workspace, as it is the case for the systems supported by sophisticated geometric modelers. After explaining the main ideas underlying the approach, a set of experimental results are presented and discussed in some depth.

We discuss a practical motion planning strategy based on a two-step approach. First, an approximation of the C-space is built by a plane-sweep algorithm. Then, the search for a solution path drives the necessary refinement steps. Our claim is that an approach based on the incremental characterization of the C-space can be competitive with the best proposed motion planning techniques. We substantiate this claim in the simple case of planning translations of a convex body in the plane. Since the shape of the free space is incrementally recognized by probing the space via collision detection, every item of geometric information is obtained from the analysis of contact configurations involving convex bodies. At any stage the probes provide a partial characterization, represented by a simple cell subdivision and a suitable set of chains approximating the boundaries of the grown obstacles. The cells and their adjacencies do not change during the refinement step, so that the search strategy is straightforward. Although the performances are not optimal in theory, the planning algorithm shows a good behaviour, as demonstrated by a few experiments where it is compared with a quadtree-based strategy.

Starting from their (1989) past work on geometric modelling, the authors discuss various techniques for the robot motion planning problem and suggest further work in this field. The efficiency of any approach to motion planning is strongly related to the ability of getting relevant information from a small subset of the geometric items. Considering a restricted portion of the configuration space around the current configuration of the introduces some local issues. So, a spatial reasoning system is defined by the interactions between local focusing and a global view of the planning process.>