Publications
-
(2019) Informatics in Education. 18, 1, p. 105-129 Abstract
This paper describes a study of students' meaningful learning of the engineering design process during their participation in robotics activities. The population consisted of middle-school students (ages 13-15 years) who participated in the FIRST (R) LEGO (R) League competition. The methodology used was qualitative, including observations and interviews. The analysis was based on the Revised Bloom Taxonomy. Almost all the groups demonstrated meaningful learning, although some reached higher levels than others. Most of the groups demonstrated the understanding/applying level during each of the design process phases (searching and decision making, construction and testing, diagnosing and debugging), some demonstrated the analyzing/evaluating level, but only a few demonstrated the higher level of creating. Factors that seemed to play a role in the students' learning include: (a) the teaching or mentoring style; (b) the absence of a robotics textbook; (c) the extra-curricular competition-oriented nature of the activities; and (d) the unstable nature of the design of the robot.
-
(2018) Journal of Computational Science Education. 9, 2, p. 2-13 Abstract
Students face many difficulties dealing with physics principles and concepts during physics problem solving. For example, they lack the understanding of the components of formulas, as well as of the physical relationships between the two sides of a formula. To overcome these difficulties some educators have suggested integrating simulations design into physics learning. They claim that the programming process necessarily fosters understanding of the physics underlying the simulations. We investigated physics learning in a high-school course on computational science. The course focused on the development of computational models of physics phenomena and programming corresponding simulations. The study described in this paper deals with the development of students' conceptual physics knowledge throughout the course. Employing a qualitative approach, we used concept maps to evaluate students' physics conceptual knowledge at the beginning and the end of the model development process, and at different stages in between. We found that the students gained physics knowledge that has been reported to be difficult for high-school and even undergraduate students. We use two case studies to demonstrate our method of analysis and its outcomes. We do that by presenting a detailed analysis of two projects in which computational models and simulations of physics phenomena were developed.
-
(2018) International Journal of Computer Science Education in Schools. 2, 3, Abstract
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.
-
(2018) Journal of Open Source Software. 3, 24, Abstract
Many problems can be solved by encoding them as formulas in propositional logic which are checked for satisfiability by a program called a SAT solver. If found, a satisfying assignment provides the answer to the problem. Donald Knuth (Knuth 2015) calls SAT solvers a killer app because diverse practical problems can be solved by a single, highlyoptimized, program. Despite their importance, SAT solvers are described only in research papers. LearnSAT is designed for teaching and learning SAT solving by providing a concise, well-documented, implementation, fine-grained tracing (both textual and graphical) of the algorithms and a detailed tutorial. LearnSAT implements the core algorithms of modern SAT solvers (Biere et al. 2009): the Davis-Putnam-Logemann-Loveland (DPLL) algorithm with conflict-driven clause learning (CDCL) and non-chronological backtracking (NCB). CDCL is implemented by backwards resolution from a conflict clause to a unique implication point (UIP) (Marques-Silva, Lynce, and Malik 2009). It is also possible to compute dominators in the implication graph. In addition, two heuristics for lookahead are implemented. The user of LearnSAT can choose any subset of 24 display options in order to tailor the output to a specific learning context. The display options include elementary steps like decision assignments, unit propagations and identifying conflict clauses, as well as the advanced steps of CDCL: the resolution steps used to obtain a learned clause and the search for UIPs. LearnSAT can generate two types of graphs that are rendered using the dot tool: trees showing the search through the assignments and implication graphs that display the process for learning clauses from conflicts. LearnSAT is implemented in Prolog and was developed using SWI-Prolog which available for Windows, MacOSX and Linux, although almost all the source code is compatible with the standard.
-
(2018) Cham: . Abstract
This book bridges the gap between playing with robots in school and studying robotics at the upper undergraduate and graduate levels to prepare for careers in industry and research. Robotic algorithms are presented formally, but using only mathematics known by high-school and first-year college students, such as calculus, matrices and probability. Concepts and algorithms are explained through detailed diagrams and calculations. Elements of Robotics presents an overview of different types of robots and the components used to build robots, but focuses on robotic algorithms: simple algorithms like odometry and feedback control, as well as algorithms for advanced topics like localization, mapping, image processing, machine learning and swarm robotics. These algorithms are demonstrated in simplified contexts that enable detailed computations to be performed and feasible activities to be posed. Students who study these simplified demonstrations will be well prepared for advanced study of robotics. The algorithms are presented at a relatively abstract level, not tied to any specific robot. Instead a generic robot is defined that uses elements common to most educational robots: differential drive with two motors, proximity sensors and some method of displaying output to the use. The theory is supplemented with over 100 activities, most of which can be successfully implemented using inexpensive educational robots. Activities that require more computation can be programmed on a computer. Archives are available with suggested implementations for the Thymio robot and standalone programs in Python.
-
(2017) International Conference on Robotics and Education RiE 2017. Obdrzalek D., Koppensteiner G., Merdan M., Balogh R. & Lepuschitz W.(eds.). Cham: . p. 77-87 Abstract
We taught computer science (cs) with robotics to four second-grade classes of 30 students each (ages 78). The lessons were taught using the Thymio robot and the vpl environment. Our goal was to investigate the extent to which students actually learn cs concepts. A taxonomy was developed to characterize the learning levels. The students answered two questionnaires based on the taxonomy and field observations were recorded. We found that students at such an early age were very engaged during the robotics activities and were highly motivated to succeed. Furthermore, these young students do learn cs concepts but find it difficult to create and run their own programs.
-
(2017) International Conference on Robotics and Education RiE 2017. Obdrzalek D., Koppensteiner G., Merdan M., Balogh R. & Lepuschitz W.(eds.). Cham: . p. 132-137 Abstract
We used the theory of planned behavior to predict students intentions to choose STEM (science, technology, engineering and mathematics) in the transition from middle school to high school after participating in robotics activities. We found that students attitudes towards STEM were not as high as expected, although most of them expressed an intention to choose future study of STEM. Then we interviewed teachers on their attitudes on the effect of robotics activities on choosing to study STEM, and checked if the activities actually led to an increase in students choosing STEM. We found positive results for both questions.
-
-
(2015) International Conference on Informatics in Schools. Brodnik A. & Vahrenhold J.(eds.). p. 22-31 Abstract
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.
-
(2015) Proceedings of the Workshop in Primary and Secondary Computing Education. Vahrenhold J., Gal-Ezer J. & Sentence S.(eds.). p. 102-110 Abstract
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.
-
(2015) Computers & Education. 87, p. 10-23 Abstract
College and high-school students face many difficulties when dealing with physics formulas, such as a lack of understanding of their components or of the physical relationships between the two sides of a formula. To overcome these difficulties some instructors suggest combining simulations' design while learning physics, claiming that the programming process forces the students to understand the physical mechanism activating the simulation. This study took place in a computational-science course where high-school students programmed simulations of physical systems, thus combining computer science (CS) and mathematics with physics learning. The study explored the ways in which CS affected the students' conceptual understanding of the physics behind formulas. The major part of the analysis process was qualitative, although some quantitative analysis was applied as well. Findings revealed that a great amount of the time was invested by the students on representing their physics knowledge in terms of computer science. Three knowledge domains were found to be applied: structural, procedural and systemic. A fourth domain which enabled reflection on the knowledge was found as well, the domain of execution. Each of the domains was found to promote the emergence of knowledge integration processes (Linn & Eylon, 2006, 2011), thus promoting students' physics conceptual understanding. Based on these findings, some instructional implications are discussed.
-
(2015) Proceedings of the 2015 ACM Conference on Innovation and Technology in Computer Science Education. p. 153-158 Abstract
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.
-
(2015) ACM Transactions on Computing Education (TOCE). 14, 4, 25. Abstract
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.
-
(2015) Olympiads in informatics. 9, p. 89-112 Abstract
This work investigates students learning of computer science (CS) as part of a research project on students learning of and attitudes toward STEM (Science, Technology, Engineering, and Mathematics) subjects during their participation in robotics activities. The population consisted of groups of middle-school students (ages 1315 years) who participated in the FIRST® LEGO® League competition. The methodology used is both qualitative and quantitative using questionnaires, observations and interviews during the school year 20122013, and mainly group interviews during the school year 20132014. A representational model was used during the interviews to facilitate externalizing the students understanding of STEM concepts. The analysis used the revised Bloom Taxonomy (BT) to study the students meaningful learning. Two CS concepts were investigated: input-output and interfacing with sensors. The results showed that during their preparation for the competition, almost all the students demonstrated meaningful learning, although some students reached higher levels of the BT than others.
-
(2014) Proceedings of the 9th Workshop in Primary and Secondary Computing Education. p. 16-19 Abstract
Abstraction is a fundamental concept in computer-science (CS) and other scientific disciplines. This paper examines the ways CS thinking patterns can contribute to achieving high levels of abstraction in physics. We examined the work of high school students taking a computational science course, where they designed computational models (simulations) of physics phenomena. We examined the evolution of their use of levels of abstraction in physics, using the framework of Epistemic Games [14]. Findings revealed that moving between levels of abstraction in CS enabled the students to move between levels of abstraction in physics. In particular, in CS the students moved from the high level of what the simulation should do to the low level of how it is done. At the same time, in physics they moved from the low level of thinking on a concrete physics phenomenon to the high level of formulating mathematical equations.
-
(2014) ITICSE 2014 - Proceedings of the 2014 Innovation and Technology in Computer Science Education Conference. p. 352 Abstract
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.
-
(2014) Proceedings of the 2014 conference on Innovation technology in computer science education. p. 315-320 Abstract
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.
-
(2014) p. 94-99 Abstract
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 has been taught in secondary schools, a fact that led researchers to wonder about the effect of combining disciplines on students' learning. Specifically, we investigated the effect of CS while actively designing a simulation, on students achieving a higher level of conceptual learning in physics. We used the knowledge integration (KI) framework (Linn & Eylon, 2006, 2011) to analyze the students' learning. This framework describes four processes that should underlie meaningful learning. Our findings indicate that CS frequently caused the emergence of the KI processes. For example, in constructing a computer simulation of physical phenomena, students represented their physics knowledge in a concrete form that provides criterion which they can use to assess their knowledge.
-
(2013) Computer Science Education. 23, 3, p. 239-264 Abstract
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 (CS). We developed learning materials for middle-school students that were designed according to the constructionist philosophy of Scratch and evaluated them in a few schools during two years. Tests were constructed based upon a novel combination of the revised Bloom taxonomy and the Structure of the Observed Learning Outcome taxonomy. These instruments were augmented with qualitative tools, such as observations and interviews. The results showed that students could successfully learn important concepts of CS, although there were problems with some concepts such as repeated execution, variables, and concurrency. We believe that these problems can be overcome by modifications to the teaching process that we suggest.
-
-
(2013) International Conference on Informatics in Schools: Situation, Evolution, and Perspectives. p. 127-137 Abstract
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.
-
-
LearnSAT: a SAT solver for education(2013) International Conference on Theory and Applications of Satisfiability Testing. p. 403-407 Abstract
-
(2012) ACM Inroads. 3, 3, p. 36-38 Abstract
Recent versions of the Spin model checker support search diversity, where the depth-first search of the state space of computation can be randomized. We show how to use this feature to demonstrate the efficacy of random and parallel algorithms when applied to SAT solving: finding a satisfying interpretation of a formula of propositional logic.
-
(2012) ACM Transactions on Computing Education (TOCE). 12, 2, a8. Abstract
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.
-
(2012) 3rd ed. Abstract
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 students of computer science. The method of semantic tableaux provides an elegant way to teach logic that is both theoretically sound and easy to understand. The uniform use of tableaux-based techniques facilitates learning advanced logical systems based on what the student has learned from elementary systems.The logical systems presented are: propositional logic, first-order logic, resolution and its application to logic programming, Hoare logic for the verification of sequential programs, and linear temporal logic for the verification of concurrent programs.
-
(2011) Proceedings of the 11th Koli Calling International Conference on Computing Education Research. p. 39-48 Abstract
In this paper we present a study of how students make use of Atropos, a new visualisation system that is based upon dependence graphs, while debugging concurrent programs. We examine how students work by identifying their operation foci, and use these as a basis for identifying the students' approaches to debugging concurrent programs. We also identify the types of understanding of a concurrent program Atropos helped them to gain, and the situations in which they did not manage to get the information they wanted from Atropos. We use the latter as a starting point for discussing improvements to make Atropos more useful for students.
-
(2011) Journal of Visual Languages and Computing. 22, 5, p. 375-384 Abstract
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.
-
(2011) Visualizing software for understanding and analysis (VISSOFT), 2011 6th IEEE international workshop on. p. 1-4 Abstract
Atropos is a software tool for visualising concurrent program executions intended to help students debug concurrent programs and learn how concurrency works. Atropos supports a slicing debugging strategy by providing a visualisation of dynamic dependence graphs that can be explored to trace the chain of events backwards from a symptom to its cause. In this paper, we present the reasoning behind the design of Atropos and summarise how we evaluated it with students.
-
(2011) Communications of the ACM. 54, 7, p. 35-37 Abstract
Keywords: Computer Science, Hardware & Architecture; Computer Science, Software Engineering; Computer Science, Theory & Methods
-
(2011) Proceedings of the 16th annual joint conference on Innovation and technology in computer science education. p. 168-172 Abstract
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.
-
(2011) Proceedings of the 16th annual joint conference on Innovation and technology in computer science education. p. 387-387 Abstract
SyntaxTrain parses a Java program and displays the syntax diagrams associated with a syntax error.
-
(2011) ACM Inroads. 2, 1, p. 27-28 Abstract
The constructs for loops in Scratch are presented and compared with those in mainstream programming languages like Java. There are significant differences in the semantics of loops that have the potential for causing confusion when students move from Scratch to another language.
-
(2011) Proceedings of the Workshop on Parallel and Distributed Systems: Testing, Analysis, and Debugging. p. 15-25 Abstract
In this article, we present a system intended to help students understand and debug concurrent Java programs. The system instruments Java classes to produce execution traces. These traces can then be used to construct a dynamic dependence graph showing the interactions between the different operations performed in the program. These interactions are used as the basis for an interactive visualisation that can be used to explore the execution of a program and trace incorrect program behaviour back from a symptom to the execution of incorrect code.
-
-
(2010) ACM Inroads. 1, 1, p. 40-47 Abstract
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.
-
(2010) Abstract
A textbook for teaching ideas and concepts of computer science to middle-school students, utilizing the Scratch environment. The book follows a problem-based approach, where the ideas and concepts emerge when needed to solve a problem. The solution process emphasizes the algorithm phase, where the new concepts are taught in their general CS meaning and only then moves on to the programming phase, where Scratch components are presented for implementing the new concepts.
-
(2010) ICER'10 - Proceedings of the International Computing Education Research Workshop. p. 69-76 Abstract
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.
-
(2009) Science & Education. 18, 8, p. 1005-1030 Abstract
Nondeterminism is a fundamental concept in computer science that appears in various contexts such as automata theory, algorithms and concurrent computation. We present a taxonomy of the different ways that nondeterminism can be defined and used; the categories of the taxonomy are domain, nature, implementation, consistency, execution and semantics. An historical survey shows how the concept was developed from its inception by Rabin & Scott, Floyd and Dijkstra, as well as the interplay between nondeterminism and concurrency. Computer science textbooks and pedagogical software are surveyed to determine how they present the concept; the results show that the treatment of nondeterminism is generally fragmentary and unsystematic. We conclude that the teaching of nondeterminism must be integrated through the computer science curriculum so that students learn to see nondeterminism both in terms of abstract mathematical entities and in terms of machines whose execution is unpredictable.
-
(2009) ITiCSE-2009 - Proceedings of the 2009 ACM SIGCSE Annual Conference on Innovation and Technology in Computer Science Education. p. 99-103 Abstract
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.
-
Tool Presentation: Teaching Concurrency and Model Checking(2009) Model Checking Software. 5578, p. 6-11 Abstract
This paper describes software tools for teaching concurrency and model checking. JSPIN is an development environment for SPIN that formats and filters the output of a simulation according to the user's specification. SPINSPIDER. uses debugging output from SPIN to generate a diagram of the state space of a PROMELA model, the diagram can be incrementally displayed using IDOT. VN supports teaching nondeterministic finite automata. The ERIGONE model checker is a partial reimplementation of SPIN designed to be easy to use, well structured and well documented. It produces a full trace of the execution of the model checker in a format that is both readable and amenable to postprocessing.
-
(2009) ACM Transactions on Computing Education (TOCE). 9, 1, p. 7 Abstract
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.
-
(2009) Computer Science Education. 19, 2, p. 51-67 Abstract
This article describes how research methodologies were modified and integrated during the doctoral research conducted by the first author under the supervision of the second author. The research project concerned trying to understand why teachers do or don't use Jeliot, a program animation...
-
(2009) Proceedings of the Chais conference on instructional technologies research 2009. p. 41-47 Abstract
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.
-
(2008) (truetest series). Abstract
The Spin model checker is a widely used professional software tool for specifying and verifying concurrent and distributed systems. Models, written in a simple language called Promela, can be simulated randomly or interactively. Spin can generate efficient verifiers that search for a counterexample to correctness specifications applied to a model. Spin is also a superb tool for teaching important concepts of computer science such as verification, concurrency and nondeterminism. The Promela language is easy to learn, as is the linear temporal logic used for correctness specifications, and the techniques for simulating and verifying models. Principles of Spin is an introductory book for students and practicing software engineers who wish to learn Promela and Spin. The presentation starts with the verification of sequential programs and proceeds in gradual stages to the verification of concurrent and then distributed programs. Complete programs are used to demonstrate each construct and concept, and the source code of these programs, together with that of longer case studies, are available on the companion website. The book describes free software that the author has developed: jSpin-an integrated development environment for Spin, SpinSpider-a visualization tool that automatically constructs graphical state diagrams of concurrent programs, and VN-a Spin-based tool for visualizing nondeterminism of finite automata. 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.
-
(2008) Sigcse'08: Proceedings Of The 39Th Acm Technical Symposium On Computer Science Education. p. 4-8 Abstract
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 effect of the Jeliot animation system on learning elementary programming(2008) 4th Panhellenic Conference on Didactics of Informatics. p. 28-30 Abstract
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.
-
(2008) Journal of the Learning Sciences. 17, 1, p. 1-32 Abstract
We explain certain learning difficulties in computer science education as resulting from a clash between the students' culture as computer users and the professional computing culture. We propose the concept of fertile zones of cultural encounter as a way of overcoming these learning difficulties. This pedagogical approach aims to bridge the gap between cultures by designing interventions that are appreciated by members of both cultures, yet also guide the student to engage in the practices of the professional culture. The learning difficulties are demonstrated by a detailed analysis of episodes taken from an advanced high school computer science course in concurrency. We show that fertile zones of cultural encounter can be successful in significantly improving learning of this subject.
-
(2008) ACM SIGCSE Bulletin. 40, 3, p. 169-173 Abstract
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.
-
(2007) Skeptic. 13, 2, p. 20-27 Abstract
Because science has advanced so rapidly over the past century or so, we assume that it can and will continue to do so, possibly forever. But science itself tells us that there are limits to our knowledge. The book "End of Science" argued that science - especially pure science, the grand request to understand the universe and our place in it - might be entering an era of diminishing returns. We would like to see a greater recognition of science's limitations, particularly in mind-related fields, where our desire for self-knowledge can make us susceptible to pseudo scientific cults such as Marxism, social Darwinism, eugenics, and psychoanalysis. Science is never more dangerous than when it seeks to tell us what we are, what we can be, and even what we should be.
-
(2007) Computer Science Education. 17, 2, p. 117-127 Abstract
This paper describes a visualization environment and associated learning activities designed to improve learning of computer architecture. The environment, EasyCPU, displays a model of the components of a computer and the dynamic processes involved in program execution. We present the results...
-
(2007) ACM SIGCSE Bulletin. 39, 3, p. 246-250 Abstract
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.
-
(2006) Interacting with Computers. 18, 6, p. 1336-1350 Abstract
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.
-
(2006) ACM SIGCSE Bulletin. 38, p. 75-77 Abstract
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.
-
(2006) Proceedings of the second international workshop on computing education research. p. 1-5 Abstract
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.
-
(2006) PPIG2006-Proceedings of the 18th Annual Workshop of the Psychology of Programming Interest Group. p. 266 - 274 Abstract
Abstract. This paper describes an investigation into the factors affecting a students 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.
-
(2006) Computer Science Education. 16, 4, p. 261-279 Abstract
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.
-
(2006) 2nd ed. Abstract
While there are no specific prerequisites and the book is reasonably self-contained, a student should be fluent in one or more programming languages and have a basic knowledge of data structures and computer architecture or operating systems. There is a companion website with an archive of source code.
-
(2005) SIGCSE Bulletin Inroads. 37, 4, p. 39-40 Abstract
Richard Kaye's demonstration that a puzzle based on the Minesweeper game is NP-complete makes this important computer science topic accessible to high school students. The resource described here is a set of slides showing the detailed solution of two introductory puzzles, following by the step-by-step simulation of digital circuit elements required for proving NP-completeness.
-
(2005) Computer Science Education. 15, 3, p. 203-221 Abstract
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.
-
(2005) ACM SIGCSE Bulletin. 37, 1, p. 101-105 Abstract
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.
-
(2005) ACM SIGCSE Bulletin. 37, 1, p. 226-230 Abstract
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.
-
Whose final hour?: The problem of naive egocentric catastrophism in doomsayers and catastrophists(2005) Skeptic (Altadena, CA). 12, 3, p. 40-50 Abstract
Naive egocentric catastrophism (NEC) is not based on sound science. Instead, it borders on pseudoscience, and discourages serious and sober debate on the scientific issues in potential catastrophes arising from global warming, depletion of resources, terrorism, and all the rest. Ben-Ari criticizes various works of the NEC genre, and briefly discusses the work of Brian Fagan and Jared Diamond, two authors who write responsibly about catastrophes, collapses, and realistic threats to the future.
-
(2005) Proceedings of the Thirty-Sixth SIGCSE Technical Symposium on Computer Science Education, SIGCSE 2005. Vol. 37. p. 196 Abstract
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.
-
(2005) Science Education. 14, 3-5, p. 367-376 Abstract
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.
-
(2005) 2nd ed. Abstract
Ada is the programming language of choice for high integrity software systems and is used extensively in industries such as transportation and aerospace. This textbook is intended for experienced programmers (advanced students and practicing software engineers) who need to master software design and programming in Ada. Special features of the book include: The constructs of the language are taught within the context of large case studies such as a discrete event simulation. Object-oriented programming, concurrency, and embedded and real-time systems are emphasized. Ada for Software Engineers explains the language concepts and the terminology of the standards document, the Ada Reference Manual (ARM). Extracts from the ARM are used throughtout and there are extensive cross references to the ARM. A comprehensive glossary and quizzes assist the reader in developing the ability to use the ARM as a practical reference. Comparisons with familiar languages like C and Java are given to facilitate the transition to Ada. The features of Ada 2005 are used routinely, but they are carefully identified, so that programmers using Ada 95 will also find the textbook useful. The companion website contains the full source code of nearly 100 case studies and 100 technical quizzes.
-
Selecting a visualization system(2004) Proceedings of the Third Program Visualization Workshop. p. 134-140 Abstract
This paper describes the selection of an algorithm visualization system for use in a high-school course on data structures. While the selection criteria and the evaluations of the systems are highly specific to the particular educational context, we believe that it will be helpful to share our experience with others. Even more important, we wish to point out areas in which none of the systems fulfilled our requirements, so that developers of existing or future visualization systems can take them into account.
-
(2004) Computer Science Education. 14, 2, p. 85-100 Abstract
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.
-
(2004) ITiCSE '04: Proceedings of the 9th annual SIGCSE conference on Innovation and technology in computer science education. 3 ed. Vol. 36. p. 230-231 Abstract
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 a 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 a 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 a successful research process ([5], [6], [12]).These initiatives do not advocate the primacy of a certain approach over others. This openness is well-grounded, since "a particular approach offers certain perspectives on a 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 a particular approach, and thereby illustrate its use.
-
(2004) Proceedings of the working conference on Advanced visual interfaces. p. 373-376 Abstract
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.
-
(2004) ACM SIGCSE Bulletin. 36, 1, p. 392-396 Abstract
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.
-
(2004) Computer Science Education. 14, 1, p. 1-2 Abstract
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.
-
Inside the computer: Visualization and mental models(2004) Proceedings of the Third Program Visualization Workshop. p. 82-85 Abstract
The EasyCPU environment was developed for teaching computer architecture to high school students of computer science. As a result of experience during the development, it was decided to perform 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).
-
(2004) ITiCSE '04. p. 52-56 Abstract
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.
-
(2004) ITiCSE '04. p. 265 Abstract
The noice-oriented GUI and animation display, Jeliot 3, is studied. Jeliot 3 introduces a new kind of design in order to make the system extendable and to add new features. It 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 can be used as a tool in interactive laboratory session.
-
-
-
(2003) ITiCSE04, June 2830, 2004, Leeds, United Kingdom. Abstract
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.
-
(2003) Science and Education. 12, 7, p. 719-723 Abstract
Stephen Jay Gould presented his position on science and religion Non-Overlapping Magisteria (NOMA) without justification. A detailed justification of the NOMA position can be found in the earlier work of scientist and philosopher Yishayahu Leibowitz; his work is especially interesting because it comes from a religious person. This paper summarizes Leibowitz's philosophical and theological position, and claims that his version of NOMA, and by implication similar versions of NOMA, are not applicable in science education.
-
(2003) Computers & Education. 40, 1, p. 1-15 Abstract
Jeliot 2000 is a program animation system intended for teaching introductory computer science to high school students. A program animation system is a system that displays a dynamic graphical representation of the execution of a program. The goal is to help novices understand basic concepts of algorithms and programming like assignment, I/O and control flow, whose dynamic aspects are not easily grasped just by looking at the static representation of an algorithm in a programming language. The paper describes the design and implementation of Jeliot 2000 and an experiment in its use in a year-long course. The experiment showed that animation provides a vocabulary and a concrete model that can improve the learning of students who would otherwise have difficulty with abstract computer-science concepts.
-
(2002) p. 94-95 Abstract
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.
-
(2002) Abstract
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]
-
(2002) Proceeding of 2nd Program Visualization Workshop. p. 83-89 Abstract
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]
-
(2002) Tools and Environments for Learning Object-Oriented Concepts. p. 30-43 Abstract
... 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]
-
Perspectives on program animation with Jeliot(2002) Software Visualization. 2269, p. 31-45 Abstract
The Jeliot family consists of three program animation environments which are based on a self-animation paradigm. A student can visualize her Java code without inserting additional calls to animation primitives. The design of the animation environments has been guided by the analysis of feedback from high school and university students. Evaluation studies indicate the benefit of dedicated animation environments for different user groups like novice programmers. Based on the results of these studies, we present plans for a future work on Jeliot.
-
(2001) Science Education. 10, 5, p. 477-484 Abstract
Scientists usually identify themselves as either theoreticians or experimentalists, while technology the application of science in practice is done by engineers. In computer science, these distinctions are often blurred. This paper examines the history of major achievements in computer science as portrayed by the winners of the prestigious Turing Award and identifies a possibly unique activity called Theory-Guided Technology (TGT). Researchers develop TGT by using theoretical results to create practical technology. The reasons why TGT is practical in computer science are discussed, as is the cool reception that TGT has been received by software engineers.
-
(2001) Journal on Educational Resources in Computing (JERIC). 1, 2es, 384055.384. Abstract
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.
-
Salvation for bricoleurs(2001) p. 225-235 Abstract
Users demonstrate bricolage (aimless trial and error) in their interaction with applications like word processors. This can be attributed to behaviorist and minimalist task-oriented learning. We show that explicitly teaching a conceptual model can improve both the task performance and the understanding of the learners.
-
(2001) 2nd Edition ed. Abstract
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.
-
Extreme interleavings(2001) IEEE Distributed Systems Online. 2, 1, Abstract
The use of concurrency simulators for teaching concurrent programming is discussed. A concurrency simulator is better than a standard concurrent language for introductory courses, as it provides fine-grained control over process scheduling. An example of a concurrent program and its results in a concurrent simulator are also given. The interleaving of all iterations in the program are also presented.
-
Constructivism in computer science education(2001) Journal of Computers in Mathematics and Science Teaching. 20, 1, p. 45-73 Abstract
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.
-
(2001) ACM SIGCSE Bulletin. 33, 2, p. 58-59 Abstract
In the 2000 December issue of inroads, Michael Williams suggested that the failure of the Ariane 5 rocket launch could be used as a case study in teaching programming concepts. Here is an article I wrote several years ago in which I present the story of the Ariane 5 in terms used to teach introductory computer science.
-
(2000) p. 131-140 Abstract
Jeliot 2000 is a program animation system intended for teaching computer science to high school students. This paper describes the design and implementation of Jeliot 2000 and an experiment in its use in a year-long course. The experiment showed that animation provides a vocabulary and a concrete model that can improve the learning of students who would otherwise have difficulty with abstract computer science concepts.
-
(2000) ACM SIGCSE Bulletin. 32, 2, p. 4-6 Abstract
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.
-
Formal verification of the Ricart-Agrawala algorithm(2000) Fst Tcs 2000: Foundations Of Software Technology And Theoretical Computer Science, Proceedings. 1974, p. 325-335 Abstract
This paper presents the first formal verification of the Ricart-Agrawala algorithm [RA81] for distributed mutual exclusion of an arbitrary number of nodes. It uses the Temporal Methodology of [MP95a]. We establish both the safety property of mutual exclusion and the liveness property of accessibility. To establish these properties for an arbitrary number of nodes, parameterized proof rules are used as presented in [MP95a] (for safety) and [MP94] (for liveness). A new and efficient notation is introduced to facilitate the presentation of liveness,proofs by verification diagrams. The proofs were carried out using the Stanford Temporal Prover (STEP) [BBC(+)95], a software package that supports formal verification of temporal specifications of concurrent and reactive systems.
-
The anthropology of semaphores(2000) Iticse 2000: Proceedings Of The 5Th Annual Sigcse/Sigcue Conference On Innovation And Technology In Computer Science Education. 32, 3, p. 21-24 Abstract
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.
-
(1999) SIGCSE Bulletin (Association for Computing Machinery, Special Interest Group on Computer Science Education). 31, 3, p. 91-94 Abstract
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.
-
DPLab: An environment for distributed programming(1999) Iticse '99: Proceedings Of The 4Th Annual Sigcse/Sigcue Conference On Innovation And Technology In Computer Science Education. 31, 3, p. 91-94 Abstract
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.
-
(1999) SIGCSE Bulletin (Association for Computing Machinery, Special Interest Group on Computer Science Education). 31, 3, p. 13-16 Abstract
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.
-
(1998) ACM SIGAda Ada Letters. 18, 6, p. 204-211 Abstract
This paper describes an implementation of the Distributed Systems Annex of Ada95. The use of Java to build the Partition Communication Subsystem provides portability and Internet compatibility of distributed applications while retaining the advantages of Ada at the application level. The implementation is done partially in Ada and partially in Java: stubs are generated by the GNAT compiler and the processing of the streams (marshalling and unmarshalling is done in Ada, while the processing of the messages required to implement of the PCS is done in Java for maximal portability.
-
Teaching object-oriented programming in Ada(1998) JOOP - Journal of Object-Oriented Programming. 11, 6, p. 39-45 Abstract
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.
-
(1998) ACM SIGCSE Bulletin. 30, 3, p. 185-188 Abstract
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.
-
(1998) Proceedings of the 6th Annual Conference on the Teaching of Computing and the 3rd Annual Conference on Integrating Technology into Computer Science Education. p. 185-188 Abstract
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.
-
-
(1998) ACM SIGAda Ada Letters. 18, 4, p. 101-106 Abstract
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.
-
(1998) Concurrency Practice and Experience. 10, 6, p. 485-496 Abstract
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) SIGCSE Bulletin (Association for Computing Machinery, Special Interest Group on Computer Science Education). 30, 1, p. 257-261 Abstract
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.
-
(1998) ACM SIGCSE Bulletin. 30, 1, p. 257-261 Abstract
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.
-
(1998) Abstract
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.
-
Synchronizing multiple clients and servers(1998) Reliable Software Technologies - Ada-Europe. 1411, p. 41-52 Abstract
This paper presents a programming paradigm for synchronizing multiple clients and servers. The solution is flexible and efficient and shows how class-wide types and protected objects can be used to achieve the effect of dispatching on entry calls.
-
Development, implementation and evaluation of a course in expert systems for high-school students (poster)(1998) SIGMOD Record. 30, 3, p. 300 Abstract
-
(1997) SIGCSE Bulletin Inroads. 29, 2, p. 7-10 Abstract
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.
-
(1997) SIGCSE Bulletin (Association for Computing Machinery, Special Interest Group on Computer Science Education). 29, 3, p. 62-64 Abstract
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.
-
(1997) Journal of Computer Science Education. 11, 3, p. 9-12 Abstract
This paper describes a novel approach to teaching recursion: couple a real-world problem that can be dramatized to a programming problem whose solution exactly parallels the dramatization. Three such pairs of problems are presented in order of difficulty: a procedure, a function and a procedure with two recursive invocations. We also show how the program for the Towers of Hanoi can be made to parallel the algorithm for playing the game.
-
(1996) ACM SIGCSE Bulletin. 28, 3, p. 51-51 Abstract
Until recently, Pascal was the first programming language taught to students. As more schools choose Ada or C++ as a first language, the debate on structured programming has been reopened ([Rob95]). We are no longer restricted to the while-statement: exit/break-statements can be used to exit a loop from the middle, and return from a procedure or function is allowed within a loop statement. Do these constructs violate the principle of structure programming? This article claims that more general loop constructs can be objectively justified, because they simplify the verification of programs. A program that is simple to verify is also easy to explain and understand.
-
(1996) ACM SIGCSE Bulletin. 28, 1, p. 180-184 Abstract
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.
-
(1990) ACM SIGAda Ada Letters. 10, 1, p. 100-103 Abstract
The response to an interrupt in a real-time program is usually divided into two parts: An interrupt handler which responds immediately to the interrupt and performs time-critical operations such as sampling a peripheral. An interrupt task which preforms the computational task required by the interrupt and is subject to less-critical scheduling.
-
(1989) ACM SIGAda Ada Letters. 10, 4, p. 159-165 Abstract
There is a class of real-time systems which I will name small systems that are characterized by limited resources. In particular, avionics systems in aircraft, spacecraft and missiles usually have the computer designed according to strict limits of size and weight and deployed systems are rarely rerofitted as technology advances. On the other hand, software is continuously being modified as the mission and the platform configuration are changed. Even a complete rewrite of the software will be more common than a change of computer hardware. [first paragraph]
-
(1986) Software - Practice and Experience. 16, 10, p. 915-924 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.
-
(1984) ACM Transactions on Programming Languages and Systems. 6, 3, p. 333-344 Abstract
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.
-
(1982) International Colloquium on Automata, Languages, and Programming. p. 14-22 Abstract
New algorithms for on-the-fly garbage collection have been presented. The basic algorithm has a correctness proof that is much simpler than that of the DLMSS algorithm. In (2), the color gray is introduced so that what we call BW(i, j, k) will always be false. Later this was found to be untenable and the invariants underwent modifications until correct ones were found. Rather than tinker with the invariants, we took the opportunity to look for changes in the algorithm which would keep the invariants simple. We do not claim to have synthesized the algorithm from the proof but do claim to have developed a good algorithm by setting simplicity of the proof as the primary goal.This simplicity has paid off since we are able to obtain other improved algorithms whose proofs are immediate modifications of the original proof. Much work needs to be done investigating the performance of this and other on-the-fly garbage collection algorithms.
-
(1982) Journal of Computer and System Sciences. 25, 3, p. 402-417 Abstract
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.
-
(1982) Abstract
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.
-
(1981) ACM SIGPLAN Notices. 16, 12, p. 22-26 Abstract
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.
-
(1981) Software - Practice and Experience. 11, 12, p. 1261-1264 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.
-
(1981) International Colloquium on Automata, Languages, and Programming. Kariv O. & Even S.(eds.). p. 249-263 Abstract
Dynamic logic, an outgrowth of modal logic, was introduced by Pratt [5] as a logical theory capable of expressing properties of computer programs. Fischer and Ladner [I] have investigated the purely logical properties of the propositional fragment of dynamic logic (PDLI. Their principal results are a decision procedure for satisfiability and a proof of the finite model property: if a formula in PDL is satisfiable then it is satisfiable a finite model; in fact one of size 2 n. These results were re-derived and extended by Pratt 1" 6, 7] who gave a ...
-
-
(1980) Information Processing Letters. 10, 2, p. 96-98 Abstract
In [2] Tseit: proved a lower bound of 2cvn on the length of a regular resolution proof in the propositional calculus. Regular resolution is resolution restricted to those trees where no literal is annihilated twice on any path from the root to a leaf. Unfortunately, Tseitins proof is published as a series of unproven lemmas. A detailed proof was given by Galil [ I]. Galil was also able to raise Tseitins 2cvn bound to 2cn.
-
(1979) IEEE Transactions on Computers. C-28, 1, p. 72-75 Abstract
Two variations on the algorithm of Eklundh for transposing large 2**n multiplied by (times) 2**n matrices, are presented. 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.
-
(1978) Acta Informatica. 10, 2, p. 117-125 Abstract
The class of Ianov schemes augmented by a pushdown memory is effectively translatable into the class of right linear boolean monadic recursive schemes. This proves a conjecture of Tokura, Kasami and Furuta [3].