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.

Young people are deterred from studying science, technology, engineering and mathematics (STEM) by the perception that such studies are boring and by a lack of self-efficacy. One approach towards increasing engagement with STEM is through the use of robotics in education, both in formal instruction and through informal activities such as competitions. There is a consensus that such activities are "fun" but there is almost no research on whether there is any educational advantage to robotics activities. We are investigating the extent to which participation in robotics education activities influence the attitudes of students towards STEM and their intentions concerning STEM studies in the future. The research framework and methodology is the theory of planned behavior (TPB), which claims that attitudes engender intentions, which in turn cause behavior. TPB is based upon questionnaires that are constructed based upon observations and interviews. The analysis of the answers from 106 questionnaires showed that the attitudes and the subjective norms were not as high as we expected, but the results for the subjective norms are of particular importance, because they show that students can be motivated by the respect and support they receive from their teachers and parents. The scores for the intentions predictor were very high, which implies that the students are like to choose to study STEM in the future.

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.

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.

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.

The difficulties of learning to program are well known. One solution that has been suggested is the use of program animation so that students are presented with a concrete representation of the dynamic execution of a program. The Jeliot program animation system was designed especially for novices learning introductory programming. This article describes the extensive pedagogical research that has been done on the use of Jeliot in various contexts.

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.

Animation systems-software tools that show a dynamic view of the execution of a program-can help novices improve their learning of programming and facilitate teaching. However, the use of such visualization tools is not as widespread as one would expect. This paper presents the results of a study of the attitudes that teachers possess on the use of the Jeliot animation system as a pedagogical tool. The results show that in spite of the fact that computer science teachers have positive behavioral beliefs about the use of animation systems in their classrooms, most of them feel a low level of perceived behavior control, and this can explain the low rate of using such tools in practice. We conclude that developers and educators should give attention to control issues relevant to the tools they develop and use.

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.

The internet is considered to have revolutionized our lives and the future is predicted to be even more revolutionary. I would like to place one aspect of modern technology--ecommerce--within an historical perspective. I examine the Sears mail-order catalog from 1897 and compare their products and services with those ecommerce pioneer Amazon.com. Amazon benefits from faster communications and transportation, but in terms of remote commerce it continues a venerable tradition, demonstrating that the internet offers few new capabilities for remote commerce that did not already exist a century ago.

Roles can be assigned to occurrences of variables in programs according to a small number of stereotypical patterns of use. Studies on explicitly teaching roles to novices learning programming have shown that roles are an excellent pedagogical tool for clarifying the structure and meaning of programs and that their use improves students' programming skills. This paper describes how roles can be applied in various programming paradigms and presents the results of three studies designed to test the understandability and acceptability of the role concept and of the individual roles in procedural, object-oriented, and functional programming. Based on the results, two new roles and small modifications to the definitions of the original roles are suggested.

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 childs 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.

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.

The more a science matures, the lower the level at which it is taught. What was once a graduate research topic becomes an undergraduate course and within a few years may be taught in high schools (HS). Computer science (CS) has now reached that stage: algorithms, programming and data structures are routinely taught in HSs, and some schools are experimenting with more advanced topics. One model for HS CS studies is to teach the content of college courses so that the students can receive credit for their studies; another model is to develop specific curricula for HS students. In general, the pedagogical issues facing high school teachers are similar, if not identical, to those teaching at the tertiary level, but differences do arise because of institutional constraints and the characteristics of the young students. The articles in this special issue all describe research carried out on the study of CS in HS. I hope that this will give the reader a glimpse on the depth of CS studies in HSs and I believe that this research is also broadly applicable to all levels of study.

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.

... talk started by addressing the difficulties that arise when teaching constructors in object-oriented programming (OOP). She presented different structures of declarations for constructors, their semantic context, their influence on programming, and aspects of students comprehension. They found that the version of declaring a constructor by initializing all attributes from parameters is preferred, even though it seems difficult to learn. Other simpler styles caused serious misconceptions with the students. [First paragraph]

In this paper, I will summarize a five-year excursion into computer science education (CSE). The excursion began with a theoretical insight, continued with experimental studies and can now be summarized in suggestions for improving the pedagogy of computer science (CS). The theoretical insight pertained to the applicability of constructivism in CSE: I concluded that students find it difficult to construct viable mental models of computers and software artifacts, because they have no pre-existing models upon which to build. I conjectured that the creation of conceptual models by educators can make it easier to acquire viable mental models, and my graduate students have performed empirical experiments to verify this conjecture. These experiments identified the important features of conceptual models that can guide educators, both teachers and developers of learning material and software. [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.

Constructivism is a theory of learning which claims that students construct knowledge rather than merely receive and store knowledge transmitted by the teacher. Constructivism has been extremely influential in science and mathematics education, but not in computer science education (CSE). This paper surveys constructivism in the context of CSE, and shows how the theory can supply a theoretical basis for debating issues and evaluating proposals.

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 paper describes a course in concurrent and distributed computing for high school students and empirical research that was done to study students' conceptions and attitudes. We found that both their conceptions and their work methods evolved during course to the point that they were able to successfully develop algorithms and to prove their correctness. Students initially found the course extremely challenging but eventually came to appreciate its relevance and its contribution to improving their cognitive skills.

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.

SimAda is a concurrency simulator, reengineered from the simulator given in M. Ben-Ari, Principles of Concurrent Programming. The language was written in Ada 95 to enhance portability and to utilise the structuring constructs of a modern language. The concurrency constructs simulated include protected types which are new for Ada 95, as well as the Ada rendezvous. Several task scheduling models can be chosen for experimentation. SimAda is intended for teaching concurrency, both by running programs and by studying the implementation techniques.

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.

Constructivism is a theory of learning which claims that students construct knowledge rather than merely receive and store knowledge transmitted by the teacher. Constructivism has been extremely influential in science and mathematics education, but not in computer science education (CSE). This paper surveys constructivism in the context of CSE, and shows how the theory can supply a theoretical basis for debating issues and evaluating proposals.

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.

Let p be a formula in deterministic propositional dynamic logic. A decision procedure for the satisfiability of p is given along with a construction of a finite model for every satisfiable p. The decision procedure runs in deterministic time 2cn and the size of the model is bounded by n2 · 4n, where n is the length of p. Finally, a complete axiomatization for deterministic propositional dynamic logic is given, based on the Segerberg axoms for propositional dynamic logic.

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.