Publications

Studying computer science (CS) in elementary schools has gained become popular in recent years. However, students at such a young age encounter difficulties when first engaging with CS. Robotics has been proposed as a medium for teaching CS to young students, because it reifies concepts in a tangible object, and because of the excitement of working with robots. We asked: What CS concepts can elementary-school students learn from the participation in a robotics based CS course? We used two theoretical frameworks to explain possible difficulties in learning: the Jourdain effect, and constructs vs. plans. A taxonomy of six levels was created to characterize levels of learning. The levels were measured using four questionnaires that were based on the taxonomy. In addition, field observations of the lessons were recorded. The population consisted of 118 second-grade students (ages 7-8). Lessons on CS concepts using Thymio educational robot and its graphical software development environment were taught during normal school hours, not in a voluntary extracurricular activity. The syllabus was based on existing learning materials that were adapted for the young age of the students. The analysis showed that the students were very engaged with the robotics activities. They did learn basic CS concepts, although they found it difficult to create and run their own programs. We concluded that the Jourdain effect was not demonstrated because the students understood concepts and constructs of CS; however, they were unable to plan and construct their own programs from the basic constructs.

This work investigates students' attitudes towards and motivation for learning robotics and STEM (Science, Technology, Engineering, and Mathematics). The population consisted of middle-school students (ages 13-15 years) who participated in the FIRST (R) LEGO (R) League competition. The methodology used both qualitative and quantitative instruments: questionnaires, observations and interviews during the school year 2012-2013. Research continued with one group during 2013-2014. Four categories were investigated: intrinsic and extrinsic motivation, self-determination and self-efficacy, as well as other environmental factors (gender, peers, parents and teachers). The results showed no significant difference between the beginning and end of the activities on all the categories. We consider this as a positive indicator, since most of the students demonstrated high and positive attitudes toward and motivation for learning robotics at the beginning of the activities and maintained the results after the activities. The environmental factors played an important role in positively influencing students' attitudes and motivation. In particular, females showed more positive attitudes and motivation at the end of the activities.

In our previous research, we showed that students using the educational robot Thymio and its visual programming environment were able to learn the important computer-science concept of event-handling. This paper extends that work by integrating augmented reality (AR) into the activities. Students used a tablet that displays in real time the event executed on the robot. The event is overlaid on the tablet over the image from a camera, which shows the location of the robot when the event was executed. In addition, visual feedback (FB) was implemented in the software. We developed a novel video questionnaire to investigate the performance of the students on robotics tasks. Data were collected comparing four groups: AR+FB, AR+non-FB, non-AR+FB, non-AR+non-FB. The results showed that students receiving feedback made significantly fewer errors on the tasks. Those using AR made fewer errors, but this improvement was not significant, although their performance improved. Technical problems with the AR hardware and software showed where improvements are needed.

Computational science is a growing scientific field that involves the design of computational models of scientific phenomena. This field combines science, computer-science (CS), and applied mathematics in order to solve complex scientific problems. In the past few years computational science is being taught in secondary schools, leading researchers to wonder about the effect of combining disciplines on students' learning. The current research is conducted in the context of a high school computational science course and investigates: the physics conceptual learning that the students achieve; the learning processes the students undergo and the effect of CS on those; the problem-solving abilities they acquire and the effect of CS on those. Findings indicate that students' conceptual understanding of physics and their problem solving abilities were enhanced and significantly influenced by CS, which served as a reflective tool representing the students' physics knowledge.

Computational science is a field that deals with the construction of computational models. It is characterized by its interdisciplinary nature. Computational science is now being taught in universities and recently even in high-schools. This paper describes research into the learning processes of tenth-grade (16-year-old) students studying a course in computational science. Following an initial finding that students achieved meaningful learning of physics, our primary goal was then to investigate the learning processes that led to this outcome. In particular, we wanted to characterize the contribution of computer science to the students' learning. We conducted a micro-level analysis of a pair of students engaged in solving a problem in computational physics. The analysis was conducted within the framework of Knowledge Integration proposed by Linn and Eylon [1,2]. We describe the learning processes that the students went through with emphasis on the contribution of computer science to learning physics; this contribution was particularly apparent in developing criteria for evaluating acquired knowledge.

Many students hold incorrect ideas and negative attitudes about computer science (CS). In order to address these difficulties, a series of learning activities called Computer Science Unplugged was developed by Tim Bell and his colleagues. These activities expose young people to central concepts in CS in an entertaining way without requiring a computer. The CS Unplugged activities have become more and more popular among CS educators and several activities are recommended in the ACM K-12 curriculum for elementary schools. CS Unplugged is used worldwide and has been translated into many languages. We examined the effect of the CS Unplugged activities on middle-school students' ideas about CS and their desire to consider and study it in high school. The results indicate that following the activities the ideas of the students on what CS is about were partially improved, but their desire to study CS lessened. In order to provide possible explanations to these results, we analyzed the CS Unplugged activities to determine to what extent the objectives of CS Unplugged were addressed in the activities. In addition, we checked whether the activities were designed according to constructivist principles and whether they were explicitly linked to central concepts in CS. We found that only some of the objectives were addressed in the activities, that the activities do not engage with the students' prior knowledge and that most of the activities are not explicitly linked to central concepts in CS. We offer suggestions for modifying the CS Unplugged activities so that they will be more likely to achieve their objectives.

Jeliot is a program animation system for teaching and learning elementary programming that has been developed over the past decade, building on the Eliot animation system developed several years before. Extensive pedagogical research has been done on various aspects of the use of Jeliot including improvements in learning, effects on attention, and acceptance by teachers. This paper surveys this research and development, and summarizes the experience and the lessons learned.

Keywords: Computer Science, Hardware & Architecture; Computer Science, Software Engineering; Computer Science, Theory & Methods

Visual programming environments are widely used to introduce young people to computer science and programming; in particular, they encourage learning by exploration. During our research on teaching and learning computer science concepts with Scratch, we discovered that Scratch engenders certain habits of programming: (a) a totally bottom-up development process that starts with the individual Scratch blocks, and (b) a tendency to extremely fine-grained programming. Both these behaviors are at odds with accepted practice in computer science that encourages one: (a) to start by designing an algorithm to solve a problem, and (b) to use programming constructs to cleanly structure programs. Our results raise the question of whether exploratory learning with a visual programming environment might actually be detrimental to more advanced study.

Model checking is a widely used formal method for the verification of concurrent programs. This article starts with an introduction to the concepts of model checking, followed by a description of Spin, one of the foremost model checkers. Software tools for teaching concurrency and nondeterminism using model checking are described: Erigone, a model checker for teaching; jSpin, a development environment; VN, a visualization of nondeterminism.

Many students hold incorrect views of what computer science (CS) is, and they have negative attitudes towards the field. In order to address these difficulties, a series of learning activities called Computer Science Unplugged was developed by Bell et al. [3]. These activities expose young people to central concepts in CS in an entertaining way, without requiring a computer. Using questionnaires and interviews, we examined the effect of the activities on middle-school students' views of CS, specifically, on their views of: (a) the nature of CS; (b) the characteristics of computer scientists and work in CS; (c) the variety of employment in CS. The results indicate thatalthough the students generally understood what CS isthey perceived the computer as the essence of CS and not primarily as a tool, contrary to the intention of the CS Unplugged activities. We suggest additions to the activities intended to increase the change in the views of CS that students have.

As collaborative learning in general, and pair programming in particular, has become widely adopted in computer science education, so has the use of pedagogical visualization tools for facilitating collaboration. However, there is little theory on collaborative learning with visualization, and few studies on their effect on each other. We build on the concept of the engagement taxonomy and extend it to classify finer variations in the engagement that result from the use of a visualization tool. We analyze the applicability of the taxonomy to the description of the differences in the collaboration process when visualization is used. Our hypothesis is that increasing the level of engagement between learners and the visualization tool results in a higher positive impact of the visualization on the collaboration process. This article describes an empirical investigation designed to test the hypothesis. The results provide support for our extended engagement taxonomy and hypothesis by showing that the collaborative activities of the students and the engagement levels are correlated.

Nondeterminism is a fundamental concept of computer science. However, since it is a very abstract concept, teaching and learning nondeterminism is difficult. In this paper we focus on one aspect of the teaching and learning processes of nondeterminism: the extent to which undergraduate students of computer science perceive that nondeterministic automata exhibit nondeterministic behavior, that is, they are unpredictable and inconsistent. First we show that students tend to think of nondeterministic automata as consistent machines; then we show that an explicit intervention can significantly affect students' mental models of nondeterministic automata in the direction of improving their perception of nondeterministic behavior.

The Jeliot program animation system for teaching introductory programming automatically animates programs in Java so that the visualizations can be created during a lecture or laboratory. We have carried out pedagogical research on the use of Jeliot in high school computer science classrooms; the research has shown that: (a) Jeliot improves learning by providing a concrete representation of the dynamic aspects of a program; (b) attention is improved; (c) while many teachers internalize the use of Jeliot, others perceive a lack of control and may limit or reject its use; (d) in a collaborative setting, the use of a visualization tool affects the level of engagement.

Animation systems-software tools that can show a dynamic view of the execution of a program-were designed to help novices improve their understanding and to help teachers facilitate learning. Preliminary studies on the effectiveness of animation systems on the understanding of students have shown encouraging results. Nevertheless, the use of animation system is not very widespread. This paper presents the results of a phenomenographic study designed to describe the different ways that teachers experience the use of an animation system as a pedagogical tool. The results suggest that increased acceptance of such tools by teachers depends on integrating the tools with other learning materials and on addressing the role of the teacher in the use of software by the students.

According to constructivism, learning takes place by constructing cognitive structures based upon current, perhaps naive, knowledge and new experiences. In the case of software artifacts like programming languages and applications, current knowledge is not a solid base upon which to build viable new knowledge. Therefore, we conjecture that explicit conceptual models constructed by educators should be able to improve the performance of users in their interaction with software artifacts, in our case the popular word processor MS-Word. The experiments described in this paper support this idea: we found that learners who used our conceptual models were able to analyze and solve problems conceptually, while learners who used task-oriented learning materials of equivalent scope employed aimless trial and error.

Abstract. This paper describes an investigation into the factors affecting a student’s decision whether to construct a state transition diagram in order to verify the correctness of a concurrent program, or whether to verbally verify the program. We conjectured that the advantages of the visual formal tool would cause it to be adopted as a routine part of the students ’ practice, but in fact the verbal description was the dominant method of their practice. This paper describes the reasoning that the students used in choosing a proof method. Psychological factors such as personal commitment and evaluation of effort turned out to be more important than the appropriateness of the tool for achieving the goal. 1.

This article describes research on the learning of object-oriented programming (OOP) by novices. During two academic years, we taught OOP to high school students, using Java and BlueJ. Our approach to teaching featured: objects-first, teaching composed classes relatively early, deferring the teaching of main methods, and focusing on class structure before algorithms. The research used a constructivist qualitative research methodology using observations and field notes, audio and video recordings, and an analysis of artifacts such as homework assignments. The findings were divided into four primary categories: class vs. object, instantiation and constructors, simple vs. composed classes, and program flow. In total, 58 conceptions and difficulties were identified. Nevertheless, at the end of the courses, the students understood the basic principles of OOP. The two main contributions of this research are: (i) the breadth and depth of its investigation into the concepts held by novices studying OOP, and (ii) the nature of the constructivist qualitative research methodology.

This paper describes research into the influence of using static (class and object) visualization on understanding program flow in object-oriented programming. We found that the advantages of using the static visualization in the first stages of learning could become disadvantages in the advanced stages. The teacher must be aware of these pitfalls and plan the learning sequence accordingly. We think that the BlueJ learning environment that we used should be augmented with dynamic visualization so that students can coordinate the static and dynamic aspects of object-oriented programs.

Lave and Wenger have proposed that learning is situated and occurs by means of legitimate peripheral participation within a community of practice, in contrast with conventional schools which are based upon the assumption that knowledge can be decontextualized. I argue that their perspective is inappropriate for science teaching, because a newcomer must have a significant amount of basic and background knowledge before entering into meaningful participation in technological communities of practice. Furthermore, situated learning can be undemocratic in that a child’s future profession is determined at a very early age. Nevertheless, science teachers in traditional schools can benefit from pedagogical insights that follow from the perspective of situated learning. The curricular content as well as the learning activities should be influenced by the nature of the activities that occur in the communities of practice that students will encounter in the future.

Jeliot is a family of program animation systems [1]. It has been successfully used to improve the teaching of intro- ductory programming by supplying a concrete language in which to explain programming structures and concepts [2]. Jeliot 3 [4] retains the novice-oriented GUI and animation display of the previous version, Jeliot 2000. Both versions automatically visualize the execution of user-written Java programs.Jeliot 3 introduces a new kind of design in order to make the system extendable and to add new features [5]. The front-end of system has been replaced by the DynamicJava interpreter, which was instrumented to produce an intermediate code, MCode, describing the program's runtime trace. The MCode trace is then rendered by the graphics back-end. The previous version of Jeliot animated variables, expressions, I/O and static method calls. Jeliot 3 is also capable of animating concepts for object-oriented programming: objects, class inheritance, constructors, method calls, instance fields, and reference semantics of arrays and objects. Jeliot 3 is intended to be a simple tool to be used in different kinds of learning scenarios [3]. It can be used to show and teach the basics of programming during a lecture. The lecturer can explain different concepts and show their corresponding animations with Jeliot. Students may use Jeliot 3 by themselves after the lectures to complete and understand the follow-up assignments related to the concepts learned at the lectures. Jeliot 3 can be used as a tool in interactive laboratory sessions. The visual display of the program can be used to facilitate communications about the errors. It can also support virtual courses, as where Jeliot 3 provides a tool that can assist students when external help is not available. Jeliot 3 is available under the GPL for downloading at http://www.cs.joensuu.fi/jeliot/. We intend to form a community around Jeliot 3, where teachers, students and developers could propose ideas and solutions in order to im- prove Jeliot 3 and the teaching of programming. The forum is available on the website and open for anyone interested. There are also plans for further development, for example, a new tool called JeCo (Jeliot Collaborative) [3] aims to integrate Jeliot 3 into a co-authoring environment where students can develop and visualize their programs together. There are also plans for further development, for example, a new tool called JeCo (Jeliot Collaborative) [3] aims to integrate Jeliot 3 into a co-authoring environment where students can develop and visualize their programs together.

Sociocultural theories of learning such as Wenger and Lave's situated learning have been suggested as alternatives to cognitive theories of learning like constructivism. This article examines situated learning within the context of computer science (CS) education. Situated learning accurately describes some CS communities like open-source software development, but it is not directly applicable to other CS communities, especially those that deal with non-CS application areas. Nevertheless, situated learning can inform CS education by analyzing debates on curriculum and pedagogy within this framework. CS educators should closely examine professional CS communities of practice and design educational activities to model the actual activities of those communities.

We present a program visualization tool called Jeliot 3 that is designed to aid novice students to learn procedural and object oriented programming. The key feature of Jeliot is the fully or semi-automatic visualization of the data and control flows. The development process of Jeliot has been research-oriented, meaning that all the different versions have had their own research agenda rising from the design of the previous version and their empirical evaluations. In this process, the user interface and visualization has evolved to better suit the targeted audience, which in the case of Jeliot 3, is novice programmers. In this paper we explain the model for the system and introduce the features of the user interface and visualization engine. Moreover, we have developed an intermediate language that is used to decouple the interpretation of the program from its visualization. This has led to a modular design that permits both internal and external extensibility.

Roles can be assigned to occurrences of variables in programs according to a small number of patterns of use that are both language- and algorithm-independent. Preliminary studies on explicitly teaching roles of variables to novice students have shown that roles are an excellent pedagogical tool for clarifying the structure and meaning of programs. This paper describes the results of an investigation designed to test the understandability and acceptability of the role concept and of the individual roles as seen by computer science educators. The investigation consisted of a short tutorial on roles, a brief training session on assigning roles to variables, a test evaluating the subjects' ability to assign roles, and a set of open questions concerning their opinions of roles. Roles were identified with 85 accuracy, and in typical uses of variables with 93 accuracy.

Roles can be assigned to occurrences of variables in programs according to a small number of patterns of use that are both language-and algorithm-independent. The concept of roles of variables is almost certainly part of the tacit knowledge of expert programmers, and we believe that explicitly teaching roles of variables to novice students can be an excellent pedagogical tool for clarifying the structure and meaning of programs. This paper describes an experiment in which computer science educators were briefly taught the concept of roles and then asked to assign roles to variables. The results showed that the subjects accepted the concept of roles as intuitive and find it easy to assign roles consistently.

Almost by definition, textbooks are written by educators. Therefore, SIGCSE conferences are an important venue for authors and publishers to meet in order to discuss projects. In computer science, textbooks become outdated very rapidly, and new subjects need new textbooks, so there are plenty of opportunities for new authors. However, prospective authors may feel a bit apprehensive about undertaking to write a textbook.In this panel, two authors will present their experiences, so that the audience can hear first-hand what it is like. The publishers viewpoint will be given by two acquisitions editors. These editors are the author's primary contact both during the negotiations leading to a decision to publish and afterwards while the book is being written. They will explain the procedures that they use and offer suggestions to improve an author's chance of acceptance.

In this paper we wish to consider the visualization of programs in the context of teaching an introductory course in object-oriented programming (OOP). We are investigating an objects-first approach, which is based on the premise that students should study OOP from the beginning so as to avoid a shift of the programming paradigm that occurs in an objects-late approach. However, objects-first is also problematical because the students are required to simultaneously master: (a) general concepts relating to computation, such as source code, compilation, execution, (b) paradigm-independent aspects of programming, such as assignment, procedure and function declaration and invocation, parameter passing, as well as (c) OOP-specific concepts, such as class, object, constructor, accessor, mutator. [First paragraph]

DAJ (Distributed Algorithms in Java) is a framework for writing Java programs to implement distributed algorithms. The programs display the data structures at each node and enable the user to interactively construct scenarios. In a learning situation, active interactive execution is preferable to passively watching an animation. Programs have been implemented for commonly taught algorithms, including the Byzantine generals, mutual exclusion, termination, and snapshots. Adding a program for another algorithm requires only general Java programming experience, as the GUI aspects are encapsulated.

Mathematical Logic for Computer Science is a mathematics textbook with theorems and proofs, but the choice of topics has been guided by the needs of computer science students. The method of semantic tableaux provides an elegant way to teach logic that is both theoretically sound and yet sufficiently elementary for undergraduates. To provide a balanced treatment of logic, tableaux are related to deductive proof systems. The logical systems presented are: - Propositional calculus (including binary decision diagrams); - Predicate calculus; - Resolution; - Hoare logic; - Z; - Temporal logic. Answers to exercises (for instructors only) as well as Prolog source code for algorithms may be found via the Springer London web site: http://www.springer.com/978-1-85233-319-5 Mordechai Ben-Ari is an associate professor in the Department of Science Teaching of the Weizmann Institute of Science. He is the author of numerous textbooks on concurrency, programming languages and logic, and has developed software tools for teaching concurrency. In 2004, Ben-Ari received the ACM/SIGCSE Award for Outstanding Contributions to Computer Science Education.

For several years I have been reviewing submissions for SIGCSE conferences and, unfortunately, recommending rejection of the majority of the submissions. While some undoubtedly deserved the recommendation, others described work that is potentially interesting and relevant, but the papers were so poorly written that it was impossible to judge the ideas fairly. I am writing this message to help SIGCSE members write better papers and improve their chances of acceptance. A review is like an audition: you have prepared your presentation for weeks or months, yet you only have a few minutes to convince a director (who knows nothing about you) that you are better than those appearing before or after you. The key words here are that the reviewer knows nothing about you. You may have been working on a project for months, but you only have four pages in which to "perform." You have two tasks when you write a paper. First, you must structure your paper so that your ideas and work are clearly and fully described within the page limit. Second, and more importantly, you must place your work in context so that the reviewer can decide if it is significant and relevant.

This article reports on my experience teaching object-oriented programming (OOP) in Ada, with emphasis on constructs that support full OOP in Ada 95. In Ada 95, this support is achieved through the integration of individual language constructs, rather than through a single syntactic entity. These constructs are easy to understand and teach, but instructors must ensure students comprehend that OOP is a programming paradigm, and that arbitrary use of the language constructs does not constitute OOP.

This paper is a tutorial on dynamic dispatching of functions with a controlling result. A case shows how to use this construct to replicate a value extracted from a heterogeneous data structure.

John Trono (1994) published a new exercise in concurrent programming - the Santa Claus problem - and provided a solution based on semaphores. His solution is incorrect because it assumes that a process released from waiting on a semaphore will necessarily be scheduled for execution. We give a simple solution in Ada 95 using higher-order synchronization primitives: protected objects and rendezvous. We then give a solution in Java, although this solution is not as elegant as the Ada 95 solution because the Java synchronization primitives are rather limited. The problem demonstrates that semaphores, designed for low-level mutual exclusion, are not appropriate for solving difficult concurrent programming problems.

As you may know, three hundred years ago at the end of the twentieth century, a monstrous earthquake shook the west coast of California. The island on which we are standing used to be part of a mountain range leading to a city that was called San Francisco. The sea between us and the mainland was a valley, called Silicon Valley in the days when silicon was used as a raw material in building computers. The repercussions of the catastrophe for US industry were so great that economic historians trace the decline of the US as a great power to this event.

The Educational Testing Service has decided that the Advanced Placement Examination in Computer Science will use the C++ programming language in place of Pascal. They have designed a subset of the language to be used in high school courses. This paper claims that the subset is deficient in two areas: (a) the subset is vague on which language features it contains, and (b) the proposed class library diverges significantly from the draft Standard Library.These problems stem from an attempt to come to terms with non-complying implementations. We believe that the AP C++ subset should be defined on educational criteria alone; software and textbook authors and publishers would then adapt their course material to the language subset.

A unified approach to program verification is suggested, which applies to both sequential and parallel programs. The main proof method suggested is that of temporal reasoning in which the time dependence of events is the basic concept. Two formal systems are presented for providing a basis for temporal reasoning. One forms a formalization of the method of intermittent assertions, while the other is an adaptation of the tense logic system Kb , and is particularly suitable for reasoning about concurrent programs.

The designers of Ada were supposed to construct a language that would be so simple, like Pascal, that no subsetting would be necessary. Though the Steelman requirements [4] forced the language to include a large number of features, it is felt that these reouirements could have been met by a far less complex language. Subsetting has become so necessary that it is administratively forbidden. Nevertheless, the prospect that even Fortran will be finally ousted is so important and so exciting that every effort must be made to encourage the use of Ada even in the face of the complexity of the language.