The activity of programming is often seen to be the epitome of all that is boring in computer science. The response of some educators is to attempt to show that programming is not the only and not even the primary activity of those engaged in CS. There is design, management, interaction with users, and so on. I would like to defend the (perhaps controversial) position that programming is the fundamental activity of CS and therefore shouldn't be swept under the rug. The position is based upon a broad view of what it means to program, so that whatever one's job title, almost everyone is programming, almost all the time. Furthermore, since the program is where "the rubber meets the road" (from a jingle used in ads for the Firestone tire company), any CS activity must be carried out with a primary focus on its contribution to the fitness of the end-product, the program. Finally, to carry out higher-level activities such as marketing and management, one must have extensive programming experience in order to successfully negotiate feasible specifications, deadlines and budgets for software development. The talk will conclude with the curricular consequences that can be drawn from this position.

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.

We implemented single-session workshops using the Thymio-II--a small, self-contained robot designed for young students, and VPL--a graphical software development environment based upon event handling. Our goal was to investigate if the students could learn this core computer science concept while enjoying themselves in the robotics context. A visual questionnaire was developed based upon the combined Bloom and SOLO taxonomies, although it proved difficult to construct a questionnaire appropriate for young students. We found that--despite the short duration of the workshop--all but the youngest students achieved the cognitive level of Unistructural Understanding, while some students achieved higher levels of Unistructural Applying. and Multistructural Understanding and Applying.

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.

Computer science (CS) activities for young students are widely used, particularly visual programming environments. We investigated the use of the Scratch environment for teaching CS concepts to middle school students. In a previous article [Meerbaum-Salant et al. 2013], we reported on the extent to which the CS concepts were successfully learned. In this article, we look at the transition from studying CS with the visual Scratch environment in middle school to studying CS with a professional textual programming language (C# or Java) in secondary school. We found that the programming knowledge and experience of students who had learned Scratch greatly facilitated learning the more advanced material in secondary school: less time was needed to learn new topics, there were fewer learning difficulties, and they achieved higher cognitive levels of understanding of most concepts (although at the end of the teaching process, there were no significant differences in achievements compared to students who had not studied Scratch). Furthermore, there was increased enrollment in CS classes, and students were observed to display higher levels of motivation and self-efficacy. This research justifies teaching CS in general and visual programming in particular in middle schools.

Much of computing education research is devoted to introductory computer science. The articles in this special issue look at the other end of the spectrum: learning advanced subjects, here, concurrent, parallel and distributed computation. The articles present four approaches for teaching these subjects using infra-structure that is feasible for educational institutions to acquire: MapReduce in a cloud, remote computing on a multicore system, a network of gaming consoles, and software modeling using formal specification.

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.

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.

SyntaxTrain parses a Java program and displays the syntax diagrams associated with a syntax error.

The decline in enrollment in computer science (CS) is often attributed to "myths" about CS: programming is boring, you have to sit in front of a computer all day, you work alone, jobs are being outsourced, etc. I believe that, by and large, these "myths" are true. Life is just like that for most people and these "myths" are true about almost all occupations, even prestigious one. Teachers, parents are counselors should be telling young people the facts of life, in particular, that CS-related occupations are among the "least worst" in these aspects. The alleged "myths" have led to a proliferation of approaches designed to make introductory CS course "fun." These approaches can be justified if they lead to improved learning by the students, but we must be careful not to plant the false idea that they necessarily correspond to real life.

Scratch is a visual programming environment that is widely used by young people. We investigated if Scratch can be used to teach concepts of computer science. We developed new learning materials for middle-school students that were designed according to the constructionist philosophy of Scratch and evaluated them in two schools. The classes were normal classes, not extracurricular activities whose participants are self-selected. Questionnaires and a test were constructed based upon a novel combination of the Revised Bloom Taxonomy and the SOLO taxonomy. These quantitative instruments were augmented with a qualitative analysis of observations within the classes. The results showed that in general students could successfully learn important concepts of computer science, although there were some problems with initialization, variables and concurrency; these problems can be overcome by modifications to the teaching process.

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 that 'although the students generally understood what CS is' they 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.

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.

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 tutorial will familiarize the participants with the use of the Spin model checker in teaching concepts such as concurrency, verification and nondeterminism. They will also learn to use pedagogical software tools that I built based upon Spin: the jSpin environment for developing and verifying concurrent programs; SpinSpider, a tool for generating graphical representations of state diagrams of concurrent programs; VN, a tool for "experiencing" the nondeterminism of finite automata.

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.

Developers of program visualization (PV) systems generally claim positive affective effects of PV usage such as increased motivation. This work attempts to characterize and measure these effects. The methodology is based on video analysis of classroom activity for behavior patterns that are associated with uncooperative attitude and attention loss. These patterns are correlated with the different learning and teaching activities that occur. The results show a near-total reduction in "bad" behavior while using PV, supporting the positive affective effects claimed for PV.

According to constructivism, learning takes place by constructing cognitive structures based upon current, perhaps naive, knowledge and new experiences. In the case

While computing technology has undoubtedly changed the world in which we live, the changes have been exaggerated. Talk of a hi-tech internet-driven revolution during the last decade is inaccurate from a historical perspective: (a) It belittles previous technological achievements; for example, the landings on the moon between 1969 and 1972 were achieved with less computing capability than a PDA has today. (b) So much of the "new" technology dates back thirty years or more; for example, how many of our students know when the first email was sent? This loss of historical perspective has led to demands for an artifact-driven curriculum that I believe is inadequate for the education of future computer scientists and computational engineers. (The latter is a new term I wish to propose for people engaged in the scientifically-based design and construction of systems that perform computations. It is linguistically modeled on the terms mechanical and electrical engineer, and is intended to take the place of the term software engineer.) A comparison of the CC2001 curriculum with the curriculum of a traditional, "non-revolutionary" engineering discipline points to what I believe the future of CS education should be.

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.

The EasyCPU visualization environment was developed for teaching computer architecture to novice students of computer science. During the development, the process of choosing the appropriate conceptual model of the computer for the visualization motivated research on the mental models that arise in the students as they learn. These mental models come from attempts by the students to make sense of the conceptual models presented to them by the software tool and their learning materials (textbook and exercises). The research findings support the view that the visualization was critical in enabling the construction of a viable mental model, a process that did not occur from textbook learning alone, because for the majority of students, their mental models were based upon their end-user experience rather than on the theoretical learning.

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.

This poster describes a suite of new or improved tools for teaching concurrent and distributed computation. The tools are written in Java for portability and are freely available at the address http://stwww.weizmann.ac.il/g-cs/~benari/software.htm, under the GNU General Public License. (Some tools invoke other programs which have different licensing arrangements.)

With our interest to improve our education in computer science, an understanding of how students learn about CS concepts, how different concepts are understood, as well as the conditions for learning, become important issues. A better understanding of our students and their learning gives us strong tool in our efforts to develop teaching. There is an increasing awareness of the usefulness of theoretically sound research approaches: it opens for generalisations of results, it invites comparison between researchers, methods and results, and at the same time it makes the limits of the research visible. As examples on initiatives that have lately been taken to promote conscious use of relevant research approaches, can be mentioned the bootstrapping project [13], the special issue on import and export of Computer Science Education (to appear), as well as papers offering overviews of the current use of certain approaches ([4], [8]) and attempts to verbalize models for successful research process ([5], [6], [12]).These initiatives do not advocate the primacy of certain approach over others. This openness is well-grounded, since a particular approach offers certain perspectives on research question, and, in this way, enables the researcher to study [these] aspects of learning, while other aspects, that are not in focus using the selected approach, become unclear or 'blurred' (Berglund, submitted for review). Thus, the selection an approach is closely intertwined with the research question under investigation.In this panel, the theoretical foundations for four different research approaches will be described, and examples of research performed within each of these approaches will be given. The examples will serve to illuminate which kinds of results that can be offered by particular approach, and thereby illustrate its use.

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.

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.

While computing technology has undoubtedly changed the world in which we live, the changes have been exaggerated. Talk of a hi-tech internet-driven revolution during the last decade is inaccurate from a historical perspective: (a) It belittles previous technological achievements; for example, the landings on the moon between 1969-1972 were achieved with less computing capability than a PDA has today. (b) So much of the "new" technology dates back thirty years or more; for example, how many of our students know when the first email was sent? This loss of historical perspective has led to demands for an artifact-driven curriculum that I believe is inadequate for the education of future computer scientists and computational engineers. (The latter is a new term I wish to propose for people engaged in the scientifically-based design and construction of systems that perform computations. It is linguistically modeled on the terms mechanical and electrical engineer, and is intended to take the place of the term software engineer.) A comparison of the CC2001 curriculum with the curriculum of a traditional, "non-revolutionary" engineering discipline points to what I believe the future of CS education should be.

The Byzantine Generals algorithm for achieving reliability in the presence of faults is a classic topic in distributed computation and operating systems, not the least because of its colorful story. We describe a concept called virtual data structures, which are concrete representations of global data structures that is not actually maintained by the nodes of a distributed system, but are required in order to understand the correctness of algorithms. We show that the use of virtual trees for the Byzantine Generals algorithm can improve the understanding of this algorithm, and we describe a visualization of the trees.

No abstract available.

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.

This paper describes research into the conceptions of students studying concurrency, using qualitative methods that originated in anthropological field work. We were able to obtain a deep understanding of students' mental models of semaphores: they construct consistent, though non-viable, models of semaphores, and they use them in patterns without understanding the synchronization context. We used the results to improve our teaching of concurrency, for example, by carefully defining the semaphore model and exercising the model outside of a problem-solving context.

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 paper describes the software package DPLab which implements an integrated GUI environment for developing distributed programs. The environment includes a text editor, a compiler, and a runtime system that establishes communications between networked computers and provides primitives for message passing between the computers. The source language is Pascal extended with these primitives and with constructs for concurrent programming. The package is implemented in Java and Swing for portability.

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.

No abstract available.

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.

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. © 1998 John Wiley & Sons, Ltd.

We show how Java can be used to develop portable implementations of distributed algorithms for class demonstrations and laboratory exploration. The programs can be used in two modes: (a) TCP/IP communications over a net, or (b) applet-to-applet communications on a single HTML page. The latter mode is important during program development and can also be used if your lab malfunctions or for homework assignments. Programs were written for four distributed algorithms: Byzantine generals, Ricart-Agrawala mutual exclusion, Dijkstra-Scholten termination and Chandy-Lamport snapshots.

The Ada programming language is an excellent vehicle for teaching concurrent programming because support for concurrency has been designed into the language. The paper shows how primitives from other concurrent programming languages (occam, Linda, Joyce) can be simulated within Ada. This enables students to study other constructs without the overhead of learning a new language and programming environment. The simulations use inheritance which was introduced into the new Ada 95 standard. They can also be used as examples of inheritance when teaching object-oriented programming.

Abstract Foreet is a software tool for the design and documentation of Fortran programs. It is based on the premise that documents accompanying a program should be computerized and integrated: computerized–to ensure fast, easy and inexpensive updating; integrated–to ensure that the documents reflect what is actually contained in the program and not some idealized notion. Foreet takes a syntactically correct Fortran program (or skeleton of a program) and comments in a specified format and writes a report. It can be used to document existing programs, though the best results will be obtained if the documentation is developed concurrently with the program. Foreet is concerned with data description and subprogram interfaces. By encouraging precise specification of these critical facets of a program, Foreet can improve the quality of programs.

A new algorithm is described for on-the-fly garbage collection.The new algorithm uses only two colors and has a simple correctness proof.Two variations on the algorithm are then derived: One attempts to minimize the amount of marking that must be done, and the other is an incremental garbage collector.

A temporal language and system are presented which are based on branching time structure. By the introduction of symmetrically dual sets of temporal operators, it is possible to discuss properties which hold either along one path or along all paths. Consequently it is possible to express in this system all the properties that were previously expressible in linear time or branching time systems. We present an exponential decision procedure for satisfiability in the language based on tableaux methods, and a complete deduction system. As associated temporal semantics is illustrated for both structured and graph representation of programs.

Abstract A system for class exercise of concurrent programming is described. The system is very simple and easy to implement yet it can demonstrate the basic concepts of concurrent programming. A detailed description of the implementation is given to enable others to adapt the system with minimal effort.

This correspondence presents two variations on the algorithm of Eklundh for transposing large 2n x 2n matrices. The first variation shows how the number of accesses to secondary storage may be reduced at the expense of an increased amount of data transferred. Formulas for I/O time are derived from which we deduce the disk characteristics under which there is an improvement. The second variation shows that a small amount of additional secondary storage can be used to greatly improve the performance of the algorithm.