Publications

Abstraction is a pivotal concept in computer science (CS); it is extensively utilized for various purposes such as problem simplification and algorithm design. Often considered the most important mental tool for computer scientists, abstraction is a key element in CS education and curricula. However, teaching CS abstraction is known to be difficult. One of the instructional methods offered in the literature to promote abstraction is pattern-oriented instruction (POI), which relies on algorithmic patterns and uses them as organizing principles and a central problem-solving strategy. Research has shown that using pattern-oriented instruction supports students abstraction abilities; however, we claim that POI alone may not be sufficient and therefore deeper exploration is required to understand the relations between employing POI, teaching abstraction and developing abstraction skills. In this qualitative study, we thoroughly analyzed the teaching approaches of eight high-school CS teachers, focusing on their use of POI and how they teach abstraction (both their perceived and actual teaching approaches). The results suggest that although POI may support the perception of the teachers as promoting abstraction, its actual implementation may not fully align with this purpose.

האקדמיה הלאומית למדעים הקימה צוות מומחים במענה לפניית "קרן טראמפ", כדי לבסס תשתית של ידע בנושא לימודי חשיבה חישובית ופיתוח בינה מלאכותית בישראל ובעולם. מאמר זה מביא את עיקרי הדו"ח שפרסמה הוועדה בחודש מאי 2025.

ion is the most fundamental idea of computer science (CS), manifested in every aspect of the discipline in multiple forms. In algorithmic problem solving, which lies at the heart of CS, it is manifested in two ways: 1) Modeling the problem and its components as computational entities, while focusing on essential core details of the problem and ignoring others. 2) Devising the solution by constantly employing algorithmic abstraction. Namely, the solution process involves moving up and down between abstraction levels, where black boxes are closed or opened, and details of the solution are ignored or considered, depending on the current phase of the problem-solving process. Models of this process can serve educators to effectively teach algorithmic problem solving, including algorithmic abstraction. Such models are often used also for assessment, for example, to examine the teaching of algorithmic problem solving or to evaluate students performance regarding algorithmic abstraction. In two different studies, we explored the teaching and learning of algorithmic abstraction in different contexts and at different age levels. In each of these studies an appropriate model of assessment was designed by means of combining top-down (deductive) and bottom-up (inductive) analyses. Thus, these models expressed grounded elements, namely, each of them included unique aspects of algorithmic abstraction that were revealed during the respective study. In this theoretical paper, we generalize these models and propose a new highly expressive two-dimensional model for evaluating algorithmic abstraction.

We currently conduct an extensive research project that investigates the implementation of a national computer science (CS) curriculum for the 4th grade. This research explores the curriculum's evolution, from the policymakers' visions, through the formal (intended) curriculum, teachers' training, and the actual implementation in class, to the educational outcomes (attained curriculum). As part of this research, we identified the educational goals of the policymakers who initiated this curriculum and examined how their goals were reflected in the formal curriculum. This paper focuses on one of the policymakers' goals-The development of algorithmic abstraction. To this end, we developed a method to investigate how algorithmic abstraction is addressed in the formal curriculum. In a recent paper, we focused on one facet of this method. Here, we will complete the presentation of this method by describing its two other facets and present the corresponding findings. Our findings indicate that the formal curriculum emphasized programming, whereas the more abstract concept of an algorithm was not sufficiently stressed. This was reflected in three ways: Most of the algorithmic problems included in the curriculum were presented using programming-related terms; algorithms and algorithm-related terms comprised a notably smaller part of the curriculum; and CS concepts were mostly introduced in terms of programming. We generalized our method to obtain a framework for assessing CS introductory curricula through the lens of algorithmic abstraction. Since abstraction is widely acknowledged as a CS fundamental idea, such a framework has significant merit for the CS educational research community.

Abstraction is a central and fundamental idea of computer science (CS), which is widely used, for example, for simplifying problems and designing algorithms. Many argue that abstraction skills are the most necessary ones for computer scientists. In line with this, abstraction is acknowledged as an essential aspect of CS curricula. However, the literature indicates that CS teachers may lack knowledge about the importance of abstraction and how to teach it. In this qualitative study we closely examined the abstraction-related teaching approaches of eight high-school CS teachers, considering both their reflections on their teaching approach and their actual classroom practice. Our findings indicate that abstraction may not be sufficiently emphasized in class. We also found gaps between the perception of some teachers regarding their abstraction-related teaching approach and their actual way of teaching abstraction in their classrooms.

Computer science education has been researched in Israel for a few decades, both at the K-12 and the undergraduate levels. The rich variety of the investigated topics addressed from the very beginning issues beyond the introductory course and programming, including the nature of the discipline and its fundamental ideas and concepts, which are stable, unlike the more technological aspects. Understanding the nature of the discipline and mapping its fundamental ideas and concepts constitute the basis on which curricula stand. Therefore, we chose to organize this chapter around ideas and concepts of CS. In line with this perspective, we will discuss research of all age levels: K-12, undergraduate, and even the graduate level, as well as research relating to teachers. We will present design-based research, which accompanied the design of new curricula, as well as studies aiming at identifying phenomena, or investigating educational hypotheses. We will also point out current challenges and possible future directions.

In a previous publication we examined the connections between high-school computer science (CS) and computing higher education. The results were promising - students who were exposed to computing in high school were more likely to take one of the computing disciplines. However, these correlations were not necessarily causal. Possibly those students who took CS courses, and especially high-level CS courses in high school, were already a priori inclined to pur-sue computing education. This uncertainty led us to pursue the current research. We aimed at find-ing those factors that induced students to choose CS at high school and later at higher-education institutes. We present quantitative findings obtained from analyzing freshmen computing students responses to a designated questionnaire. The findings show that not only did high-school CS stud-ies have a major impact on students choice whether to study computing in higher education - it may have also improved their view of the discipline.

The importance of teaching computational thinking (CT) aspart of K-12 education has led, among other factors, to the inclusion of computer science (CS) as a K-12 subject in many countries. Consequently, many CS curricula for different age levels have been or are being developed. On the long way between the policymakers and the learners, every curriculum has several manifestations. For example, differences may exist between the intended curriculum and the one implemented in class. In a large research project, we are currently investigating the evolution of a 4th-gradecurriculum in CS, starting with the vision of the policymakers, who set the teaching goals, and proceeding through the formal curriculum, then to the corresponding teacher training and classroom implementation, until the attained curriculum, as reflected in the students learning outcomes. Here, we focus on the manner in which the formal curriculum reflected the process of CS problem solving, including its inherent nature as a process that in volves transitions between multiple layers of abstraction. This major aspect of CS is perceived by many as especially important for developing CT. Our findings indicate that the treatment of problem solving in this curriculum was characterized by lower levels of abstraction. Specifically, the presentation of problems was often characterized by lower level descriptions, and the solution process often neglected the level of an algorithm and hence, also the transitions in which it was involved.

Reduction is a powerful strategy for solving proof and design problems in multiple contexts of computer science (CS). It is characterized by establishing connections between problems that may seem very different and by using black boxes. Therefore, reduction is closely related to CS abstraction. In particular, understanding and employing reduction requires one to differentiate between a problem and its solution. The latter is at a lower level of abstraction; it describes how the problem is solved, as opposed to the higher level of abstraction, which describes what the solution should achieve. A series of studies investigated the use of reduction indicating its limited use as well as specific difficulties in using it, in different contexts and age levels. In particular, the students tended to open black boxes when they used reduction and confused a problem and its solution. Following these outcomes, CS researchers presented some general guidelines for teaching reduction. The main ones recommended an explicit spiral teaching of reduction while emphasizing its characteristics and principles, and in particular, distinguishing between problems and solutions. We implemented these recommendations in an undergraduate course on algorithms and studied the effectiveness of our pedagogical framework. The findings indicate a substantial improvement in the students' use of reduction.

Many educational endeavors address the challenge of developing approaches, tools and platforms for introducing computational problem-solving skills, often referred to as computational thinking, into the school system. Plethora, a game-based platform, teaches the concepts and skills of computational problem solving, by means of graphically attractive logical challenges that are expressed in a natural language. It was developed at the Weizmann Institute of Science, in collaboration with The Israeli Center for Educational Technology. Plethora is used in schools across Israel and was selected as the leading tool for national school-level cyber competitions. In this panel, we will explain our approach towards computational problem solving, show how it is implemented with Plethora, present the scientific basis of Plethora, and finally show how Plethora can be extended to discuss computational models of scientific phenomena.

Computer science education (CSE) at the K-12 level is becoming increasingly more prevalent. Consequently, there is an urgent need for competent CS teachers; hence, also for effective training programs. The pedagogical content knowledge of CS teachers (CS-PCK) plays an important role in teachers' training. To effectively incorporate CS-PCK into teachers' training, a CS-PCK resource, which relies on the "wisdom of practice" of experienced teachers as well as the body of research on CS education would be of great value. Such a resource should consist of reliable, coherent, and self-contained CS-PCK segments, which can be used in relevant contexts with little processing and adaptation. Such a resource can also serve in-service teachers, developers of teaching materials, as well as others dealing with K-12 CS education. Constructing such a reservoir requires: 1) an effective procedure for obtaining reliable CS-PCK segments, and 2) a method for organizing CS-PCK segments that reflects their content and attributes. Herein we describe one part of a large research project on CS-PCK. In a previous publication, we reported on a method for extracting research-based CS-PCK segments from experienced teachers and established its effectiveness, thus satisfying the first requirement. The current paper concerns the second requirement. We will describe and demonstrate our innovative method for devising an incremental structure that can contain CS-PCK segments, obtained from either experienced teachers or from the CS education research literature.

The Abstraction is one of the most fundamental ideas in computer science (CS), and as such, according to Bruner [23], it should be taught spirally, starting as early as possible and revisited at every level of education. However, teaching CS abstraction to novices is a very challenging task, and CS educational research has often demonstrated students' difficulties in learning this idea, in different contexts and at different age levels. The challenge in teaching CS abstraction is even greater when dealing with young students, since according to theories on children's cognitive development, their abstraction abilities may still be not fully developed. In 2013, Armoni [5] introduced a framework for teaching abstraction in the context of algorithmic problem solving, intended for novice students. We studied the effect of this framework in an introductory CS course for 7th graders, in which Scratch was used as the programming language for implementing algorithmic solutions. Our findings indicate that the framework was highly effective for developing CS abstraction skills as well as other related skills and aspects, such as the tendency to provide explanations for solutions, the use of initialization processes, and the perception of the nature of CS. It also significantly improved students' general CS performance in this course.

The practice of teaching involves constant learning and professional growth. Professional development (PD) is necessary even for qualified in-service teachers, allowing them to enhance their disciplinary knowledge, acquire and become familiar with new pedagogical approaches, and deepen their content-pedagogical skills. Educators have suggested incorporating action research (AR) - in which teachers conduct small-scale research in their own classes - into PD of K-12 in-service teachers. An effective combination of PD and AR should, among other things, be long-term, be connected to the teachers' practice, and rely on the perspective of teachers' pedagogical content knowledge (PCK). We report on a unique PD on AR for in-service computer science (CS) K-12 teachers. This PD included a longitudinal workshop for experienced high-school CS teachers. The teachers performed AR in their own classrooms, investigating topics that they chose, based on their own personal practice, and motivated by authentic teaching challenges that they faced. In line with situated learning theory, the workshop was conducted in a rich social context. This context allowed for constant constructive feedback from peers and fostered effective reflection processes. Our findings indicate that the unique experience that the teachers underwent within the social context significantly influenced and improved their practice.

Teachers' pedagogical content knowledge (PCK) is an important factor in all that concerns teaching and learning processes. As such, it plays an important role in pre-service teachers' training and in-service teachers' professional development. In line with this, the pedagogical content knowledge of computer science teachers (CS-PCK) receives considerable attention in current computing education research. However, very little is known about effective ways of extracting valid and reliable CS-PCK segments from the practical work of CS in-service teachers, and hence, only a limited reservoir of such segments is available for CS educators. Here we report on research in which we developed and investigated a new strategy for extracting research-based CS-PCK segments from the practical work of experienced high-school teachers. This strategy incorporated action research, conducted by the CS teachers in their classes, as part of a long and extensive workshop for professional development of CS teachers. Our findings show that the use of action research within the unique platform provided by the workshop yielded a rich variety of research-based CS-PCK segments. Furthermore, our findings emphasize the important role of the social context of the workshop in teachers' success in conducting reliable and valid action research. In addition, teachers' attitudes regarding the use of action research as a tool for improving their practice were positive, as well as their tendency to adopt and use this tool in their practice.

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® LEGO® 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.

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.

In a previous study, we investigated a framework for teaching abstraction in computer science (CS) in the context of an introductory CS course for 7th-grade students. The framework was found effective for developing CS abstraction skills. In this paper, we describe a study that investigated teaching abstraction in CS to 7th-grade students through the perspective of gender. Specifically, we compared the CS abstraction abilities of boys and girls taking the introductory CS course in 7th grade (using the Scratch environment). We also examined the difference in the effect of the teaching strategy on CS abstraction abilities between boys and girls. Our findings show a significant advantage of girls over boys regarding several aspects of CS abstraction. We also found that the framework for teaching CS abstraction, which was already established in our previous study as effective in the context of an introductory course for 7th-grade students, has an enhanced effect in this context when it comes to girls. This enhancement was manifested by a better overall performance by the girls, when comparing boys and girls that took an introductory CS course in which this framework was used. It was also manifested by the girls' deeper and more reliable perception of CS. We conjecture that this framework has the potential to affect girls' self-efficacy, and as a result to create a positive effect by encouraging and motivating girls to pursue CS education beyond this introductory course. That is, this framework has the potential to contribute to solving the issue of underrepresentation of females at the different stages of CS education, or in other words, to widening the CS pipeline for females.

This is the second part of a two-part series that describes a pilot programming course in which high school students majoring in computer science were introduced to the visual, scenario-based programming language of live sequence charts. The main rationale for the course was that computer science students should be exposed to at least two very different programming paradigms and that LSCs, with their unique characteristics, can be a good vehicle for that. Part 1 (see the previous issue) focused on the pedagogic rationale of the pilot, on introducing LSC, and on the structure of the course. Part 2 centers on the evaluation of the pilots results.

This article describes a pilot programming course in which high school students were introduced, through the visual programming language of live sequence charts (LSC), to a new paradigm termed scenario-based programming. The rationale underlying this course was teaching high school students a second, very different programming paradigm. Using LSC for this purpose has other advantages, such as exposing students to high-level programming, dealing with nondeterminism and concurrency, and referring to human-computer interaction (HCI) issues. This work also contributes to the discussion about guiding principles for curriculum development. It highlights an important principle: the educational objective of a course should include more than mere knowledge enhancement. A course should be examined and justified through its contribution to learning fundamental ideas and forming useful habits of mind.

Abstraction is one of the most fundamental ideas in computer science (CS), and as such it is highly important to start teaching it as early as possible. However, teaching this soft concept to novices is a very complicated task, as has been emphasized by many CS and mathematics education experts. In this paper, we describe the first year of a study that aims to improve students' abstraction skills in algorithmic problem solving. We implement a new teaching method introduced in [2] that was designed to improve CS abstraction skills and to teach them more explicitly. We studied the effects of this teaching method in the context of an introductory CS course for 7th graders. In this course, Scratch is used as the programming language in which the solutions are implemented. We describe part of the first year's results.

Nondeterminism (ND) is a fundamental concept in computer science, and comes in two main flavors. One is the kind of ND that appears in automata theory and formal languages, and is the one that students are usually introduced to. It is known to be hard to teach. We present here a study, in which we introduced students to the second kind of ND, which we term operative. This kind of ND is quite different from the first one. It appears in nondeterministic programming languages and in the context of concurrent and distributed programming. We study how high-school students understand operative ND after learning the nondeterministic programming language of live sequence charts (LSC). To assess students' learning, we used a two-dimensional taxonomy that is based upon the SOLO and the Bloom taxonomies. Our findings show that after a semestrial course on LSC, high-school students with no previous experience with ND of either type, understood operative ND on a level that allowed them to create and execute programs that included nondeterminism on various levels and in various degrees of complexity. We believe that it is important to expose students to the two types of ND, especially as ND has become a very prominent characteristic of computerized systems. Our findings suggest that students can reach a significant understanding of operative ND when the concept is introduced in the context of a programming course.

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.

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.

Abstraction is one of the most fundamental ideas in computer science (CS). However, teaching this soft concept to novices is a very complicated task. In our research we examine a simple pedagogical strategy for teaching abstraction as part of an introductory CS unit to 7th graders. This unit covers basic ideas of CS through the use of Scratch.

Aiming to collect various concepts, approaches, and strategies for improving computer science education in K-12 schools, we edited this second special issue of the ACM TOCE journal. Our intention was to collect a set of case studies from different countries that would describe all relevant aspects of specific implementations of Computer Science Education in K-12 schools. By this, we want to deliver well-founded arguments and rich material to the critical discussion about the state and the goals of K-12 computer science education, and also provide visions for the future of this research area. In this editorial, we explain our intention and report some details about the genesis of these special issues. Following, we give a short summary of the Darmstadt Model, which was suggested to serve as a structuring principle of the case studies. The next part of the editorial presents a short description of the five extended case studies from India, Korea, NRW/Germany, Finland, and USA that are selected to be included in this second issue. In order to give some perspectives for the future, we propose a set of open research questions of the field, partly derived from the Darmstadt Model, partly stimulated by a look on large-scale investigations like PISA.

Aiming to collect various concepts, approaches, and strategies for improving computer science education in K-12 schools, we edited this second special issue of the ACM TOCE journal. Our intention was to collect a set of case studies from different countries that would describe all relevant aspects of specific implementations of Computer Science Education in K-12 schools. By this, we want to deliver well-founded arguments and rich material to the critical discussion about the state and the goals of K-12 computer science education, and also provide visions for the future of this research area. In this editorial, we explain our intention and report some details about the genesis of these special issues. Following, we give a short summary of the Darmstadt Model, which was suggested to serve as a structuring principle of the case studies. The next part of the editorial presents a short description of the five extended case studies from India, Korea, NRW/Germany, Finland, and USA that are selected to be included in this second issue. In order to give some perspectives for the future, we propose a set of open research questions of the field, partly derived from the Darmstadt Model, partly stimulated by a look on large-scale investigations like PISA.

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.

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.

Recently there has been considerable discussion regarding the importance of computer science education in schools and its absence in todays basic education in many countries. Code.org and others have tried to change the state of the art by promoting coding, which is one aspect of computer science. In this short paper we present our point of view regarding how computer science should be integrated into basic school education, while emphasizing that computer science is much more than just coding. In addition, we provide short answers to the questions: Why is it important? What should be taught and learned, when, and by whom?

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.

In this article, we discuss the possible connection between the programming language and the paradigm behind it, and programmers' tendency to adopt an external or internal perspective of the system they develop. Based on a qualitative analysis, we found that when working with the visual, interobject language of live sequence charts (LSC), programmers tend to adopt an external and usability-oriented view of the system, whereas when working with an intraobject language, they tend to adopt an internal and implementation-oriented viewpoint. This is explained by first discussing the possible effect of the programming paradigm on programmers' perception and then offering a more comprehensive explanation. The latter is based on a cognitive model of programming with LSC, which is an interpretation and a projection of the model suggested by Adelson and Soloway [1985] onto LSC and scenario-based programming, the new paradigm on which LSC is based. Our model suggests that LSC fosters a kind of programming that enables iterative refinement of the artifact with fewer entries into the solution domain. Thus, the programmer can make less context switching between the solution domain and the problem domain, and consequently spend more time in the latter. We believe that these findings are interesting mainly in two ways. First, they characterize an aspect of problem-solving behavior that to the best of our knowledge has not been studied before-the programmer's perspective. The perspective can potentially affect the outcome of the problem-solving process, such as by leading the programmer to focus on different parts of the problem. Second, relating the structure of the language to the change in perspective sheds light on one of the ways in which the programming language can affect the programmer's behavior.

The gap between enrollments in higher education computing programs and the high-tech industrys demands is widely reported, and is especially prominent for women. Increasing the availability of computer science education in high school is one of the strategies suggested in order to address this gap. We look at the connection between exposure to computer science in high school and pursuing computing in higher education. We also examine the gender gap, in the context of high school computer science education. We show that in Israel, students who took the high-level computer science matriculation exam were more likely to pursue computing in higher education. Regarding the issue of gender, we will show that, in general, in Israel the difference between males and females who take computer science in high school is relatively small, and a larger, though still not very large difference exists only for the highest exam level. In addition, exposing females to high-level computer science in high school has more relative impact on pursuing higher education in computing.

This special issue on computing education in (K-12) schools represents considerable effort by the editorial team, authors, and reviewers. It provides a series of country-specific case studies of computing education in schools that highlights the way in which curricula emerge from each countrys specific historical and cultural circumstances. As a result, not only is there much to learn from each of the case studies, but there are additional lessons in the commonalities and generalizations obtainable only by having a rich set of case studies such as these that can be viewed comparatively.

In view of the recent developments in many countries, for example, in the USA and in the UK, it appears that computer science education (CSE) in primary or secondary schools (K-12) has reached a significant turning point, shifting its focus from ICT-oriented to rigorous computer science concepts. The goal of this special issue is to offer a publication platform for soundly based in-depth experiences that have been made around the world with concepts, approaches, or initiatives that aim at supporting this shift. For this purpose, the article format was kept as large as possible, enabling the authors to explain many facets of their concepts and experiences in detail. Regarding the structure of the articles, we had encouraged the authors to lean on the Darmstadt Model, a category system that was developed to support the development, improvement, and investigation of K-12 CSE across regional or national boundaries. This model could serve as a unifying framework that might provide a proper structure for a well-founded critical discussion about the future of K-12 CSE. Curriculum designers or policy stakeholders, who have to decide, which approach an upcoming national initiative should follow, could benefit from this discussion as well as researchers who are investigating K12 CSE in any regard. With this goal in mind, we have selected six extensive and two short case studies from the UK, New Zealand, USA/Israel, France, Sweden, Georgia (USA), Russia, and Italy that provide an in-depth analysis of K-12 CSE in their respective country or state.

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.

We examine how students work in scenario-based and object oriented programming (OOP) languages, and qualitatively analyze the use of abstraction through the prism of the differences between the paradigms. The findings indicate that when working in a scenario-based language, programmers think on a higher level of abstraction than when working with OOP languages. This is explained by other findings, which suggest how the declarative, incremental nature of scenario-based programming facilitates separation of concerns, and how it supports a kind of programming that allows programmers to work with a less detailed mental model of the system they develop. The findings shed light on how declarative approaches can reduce the cognitive load involved in programming, and how scenario-based programming might solve some of the difficulties involved in the use of declarative languages. This is applicable to the design of learning materials, and to the design of programming languages and tools.

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.

Non-determinism (ND) is a fundamental concept in computer science, and comes in two main flavors. One is the kind of ND that appears in automata theory and formal languages. The other, which we term operative, appears in non-deterministic programming languages and in the context of concurrent and distributed systems. We believe that it is important to teach the two types of ND, especially as ND has become a very prominent characteristic of computerized systems. Currently, students are mainly introduced to ND of the first type, which is known to be hard to teach and learn. Our findings suggest that learning operative ND might be easier, and that students can reach a significant understanding of this concept when it is introduced in the context of a programming course that deals with a non-deterministic programming language like the language of Live Sequence Charts (LSC). Based on that, we suggest teaching operative ND in the context of concurrent and distributed programming, a topic which is covered by a new knowledge area that was added in Computer Science Curricula 2013.

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.

Abstraction is a key concept in CS, one of the most fundamental ideas underlying CS and its practice. However, teaching this soft concept to novices is a very difficult task, as discussed by many CSE experts. This paper discusses this issue, and suggests a general framework for teaching abstraction in CS to novices, a framework that would fit into most kinds of introductory courses. While this paper leans on some anecdotal evidence to support its claims, it is not an empirical work. Rather, it builds on research literature and experience in underlying some concrete rules that can assist in teaching abstraction.

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.

In this paper we present qualitative findings on the influence of previous programming experience on the learning of the visual, scenario-based programming language of live sequence charts (LSC). Our findings suggest that previous programming experience leads programmers not only to misunderstand or misinterpret concepts that are new to them, but that it can also lead them to actively distort the new concepts in a way that enables them to use familiar programming patterns, rather than exploiting the new ones to good effect. Eventually, this leads to poor usage of some of the new concepts, and also to the creation of programs that behaved differently from what the programmers expected. We also show that previous programming experience can affect programmers' attitude towards new programming concepts. Attitude is known to have an effect on performance. Since LSC and its underlying concepts are of growing popularity in the software engineering community, it is interesting to investigate its learning process. Furthermore, we believe that our findings can shed light on some of the ways by which previous programming experience influences the learning of new programming concepts and paradigms.

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.

Teaching computer science (CS) in high schools, rather than just programming or even computer literacy, is important as a means of introducing students to the true nature of CS, and enhancing their problem-solving skills. Since teachers are the key to the success of any high school educational initiative, any discussion of high school programs must consider the teachers, and specifically the teacher preparation needed to make the implementation of such programs possible. However, there is scant research on CS teacher education, probably because CS is a relatively young discipline. Very few of the publications in the area of CS teacher preparation are research-based. Most are descriptive papers, including recommendations for specific programs or courses. The purpose of this survey is to import from what is already known in other disciplines in this context. We therefore examine the body of research on teacher education in other disciplines, especially in mathematics and science, to shed light on important challenges for CS teacher education and draw some initial conclusions regarding CS teacher preparation programs.

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.

In this paper we present preliminary findings regarding the possible connection between the programming language and the paradigm behind it, and programmers tendency to adopt an external or internal perspective of the system they develop. According to the findings, when working with the visual, inter-object language of live sequence charts (LSC), programmers tend to adopt an external and usability-oriented view of the system, while when working with a language that is intra-object in nature, they tend to adopt an internal and implementation-oriented view of the system. To explain the findings, we present a cognitive model of programming that is based on that of Adelson and Soloway [1]. Our model suggests that the new paradigm of scenariobased programming, upon which LSC is based, combined with concrete interface programming and the ability to directly simulate the scenarios, allows the programmer to build systems while concentrating more on the user side. This work has two main implications. First, we believe that our findings on the programmers viewpoint are interesting in themselves. Second, it sheds light on how the LSC approach supports programming that requires less work in the solution domain. This can be applicable in areas such as novice and end-user programming.

Computer Science (CS) Education research, specifically when focusing on secondary education, faces the difficulty of regionally differing political, legal, or curricular constraints. To date, many different studies exist that document the specific regional situations of teaching CS in secondary schools. This ITiCSE working group report documents the process of collecting, evaluating, and integrating research findings about CS in secondary schools from different countries. As an outcome, it presents a category system (Darmstadt Model), as a first step towards a framework that supports future research activities in this field and that supports the transfer of results between researchers and teachers in CS education (CSE) across regional or national boundaries. Exemplary application of the Darmstadt model shows in several important categories how different the situation of CSE in secondary education in various countries can be. The Darmstadt Model (DM) is now ready for discussion and suggestions for improvement by the CSE community.

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.

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.

We present a didactical approach to the introductory computer science course in high school, and display a primary study of teachers' attitudes towards this approach. Our focus is on the presentation of computational elements and algorithm/program design, in a textbook that "zips" both theoretical and practical notions, while aiming for ease of comprehension on one hand and the development of a scientific discipline on the other. The teachers' responses to the presented approach reflect positive and constructive attitudes.

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.

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.

We describe a synthesis course that provides a hands-on treatment of many hardware and software topics learned in computer science (CS) programs. Using a modular series of twelve projects, we walk the students through the gradual construction of a simple hardware platform and a modern software hierarchy, yielding a basic yet powerful computer system. In the process of building the computer, the students gain a first-hand understanding of how hardware and software systems are designed and how they work together, as one enterprise. The course web site contains all the materials necessary to run this course in open source, and students and instructors are welcome to use and extend them freely. The course projects are modular and self-contained, and any subset of them can be implemented in any order and in any programming language. Therefore, they comprise a flexible library of exercises that can be used in many applied CS courses. This paper gives a description of the approach and the course, juxtaposed against general educational principles underlying meaningful learning.

We describe a synthesis course that provides a hands-on treatment of many hardware and software topics learned in computer science (CS) programs. Using a modular series of twelve projects, we walk the students through the gradual construction of a simple hardware platform and a modern software hierarchy, yielding a basic yet powerful computer system. In the process of building the computer, the students gain a first-hand understanding of how hardware and software systems are designed and how they work together, as one enterprise. The course web site contains all the materials necessary to run this course in open source, and students and instructors are welcome to use and extend them freely. The course projects are modular and self-contained, and any subset of them can be implemented in any order and in any programming language. Therefore, they comprise a flexible library of exercises that can be used in many applied CS courses. This paper gives a description of the approach and the course, juxtaposed against general educational principles underlying meaningful learning.

Reduction is a problem-solving strategy, relevant to various areas of computer science, and strongly connected to abstraction: a reductive solution necessitates establishing a connection among problems that may seem totally disconnected at first sight, and abstracts the solution to the reduced-to problem by encapsulating it as a black box. The study described in this article continues a previous, qualitative study that examined the ways undergraduate computer science students perceive, experience, and use reduction as a problem-solving strategy. The current study examines the same issue, but in the context of a larger population, using also quantitative analysis, and focusing on algorithmic problems. The findings indicate difficulties students have with the abstract characteristics of reduction and with acknowledging reduction as a general problem-solving strategy.

Reversing is the notion of thinking or working in reverse. Computer science textbooks and tutors recognize it primarily in the form of recursion. However, recursion is only one form of reversing. Reversing appears in the computer science curriculum in many other forms, at various intellectual levels, in a variety of fundamental courses. As such, it is too important a notion to be left unexplored. In this paper we discuss reversing in the context of two theoretical frameworksas a fundamental idea in computer science, in the context of Schwill's model of fundamental ideas, and as a powerful problem solving means, in the context of Schoenfeld's cognitive model of problem solving. We recognize seven different forms of reversing, and demonstrate the essential role of each in algorithm or proof design. Our focus in the paper is conceptual, yet we briefly note our initial experimental experience, with student difficulties in both the invocation and utilization of reversing. We then discuss cognitive aspects of the teaching of reversing and offer ways to assimilate its awareness and elaborate its fundamental role in computer science.

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 research described in this paper continues a previous, qualitative (mostly interview-based) study that examined the ways undergraduate computer science students perceive, experience, and use reduction as a problem-solving strategy. The current study examines the same issue, but in the context of a larger population, using quantitative analysis methods, and focusing on algorithmic problems.

Non-determinism is one of the most important, yet abstract, recurring concepts of Computer Science. It plays an important role in Computer Science areas such as formal language theory, computability theory, distributed computing, and operating systems. We conducted a series of studies on the perception of non-determinism. In the current research, we studied and analyzed undergraduate Computer Science students' solutions to assignments in a course on automata and formal languages. Our findings shed some light on students' perceptions of non-determinism, their tendency to use non-determinism, and the characteristics of their non-deterministic solutions. This paper describes the current research and its results, and suggests several teaching applications.

ספר זה כולל את היחידה "יסודות מדעי המחשב 1". היחידה מציגה בעיות ראשונות ואת פתרונותיהן המיועדים לביצוע למחשב. הבעיות נקראות בעיות אלגוריתמיות, ופתרונותיהן אלגוריתמים. האלגוריתמים מיושמים בתוכניות מחשב. במהלך הלימוד מוצגים המרכיבים הבסיסיים של אלגוריתמים ושל תוכניות מחשב. ההצגה משלבת פיתוח וניתוח של אלגוריתמים, וכוללת התייחסות ראשונית ַלמושג עצמים.

יחידת הלימוד "יסודות מדעי המחשב 2" היא יחידת המשך ליחידה "יסודות מדעי המחשב 1". היחידה מתבססת על הנלמד ב"יסודות מדעי המחשב 1" מחד, ומהווה שער ליחידה הרביעית "עיצוב תוכנה" מאידך. כמו "יסודות מדעי המחשב 1", גם יחידה זו משלבת שני ערוצים ערוץ תיאורטי וערוץ יישומי. מטרתה של היחידה היא להעמיק בשני הערוצים, ובעיקר להרחיב את ההיכרות עם הפרדיגמה של תכנות מונחה עצמים ואת השימוש בתבניות אלגוריתמיות.

Most college and university undergraduate CS programs have a course dealing with the theory of automata and formal languages. In most institutions, the syllabus of such a course is quite stable, and if one compares the syllabus of different institutions, chances are that no significant differences will be found in the automata and computability section of the course. Since CS is a constantly evolving and rapidly developing discipline, such stability should be a matter for serious discussion and periodic re-evaluation. Moreover, the ACM/IEEE Computing Curriculum 2001 appears to downgrade this material into a unit rather than a full-fledged course. We believe that the relevance of the course is actually greater today than ever and this important issue needs intense discussions as well.

This paper discusses the role of reduction in computer science and describes a study on undergraduate students' perception of the concept of reduction. Specifically, based on an analysis of students' answers to questions addressing different computer science topics, we present several findings regarding the ways in which undergraduate students conceive of and apply reduction. These findings can be interpreted within the framework of the tension that exists between the following two factors: The need to think in terms of high levels of abstraction, on one hand, and the fact that reduction introduces a new approach to be used in problem-solving situations, on the other. In addition the paper suggests several teaching applications.

Nondeterminism is an essential concept in mathematics and one of the important concepts in computer science. It is also among the most abstract ones. Thus, many students find it difficult to cope with. In this article, we describe some didactic considerations, which guided the development of a "Computational Models" course for high school students, a course in which the concept of nondeterminism is introduced. Some of these considerations are relevant to college and university students as well. We also discuss students' perceptions of nondeterminism and their achievements in this area. Our findings show that many students prefer to avoid nondeterminism, even when it can significantly simplify the solution's design process. We analyze and categorize the students' solutions, thus shedding light on their perceptions of the abstract concept of nondeterminism. (Contains 29 figures.)

This paper discusses the role of proofs in a course on design and analysis of algorithms. It argues that correctness proofs should always be considered as an integral part of algorithmic solutions, which should otherwise be considered as incomplete. Proofs and proof strategies should be emphasized in such a course, and active proof production should be required of students. Such an emphasis can improve mathematical as well as algorithmic skills, and can demonstrate the important and unique role of mathematics within computer science.

Most college and university undergraduate CS programs have a course dealing with the theory of automata and formal languages. In most institutions, the syllabus of such a course is quite stable, and if one compares the syllabus of different institutions, chances are that no significant differences will be found in the automata and computability section of the course. Since CS is a constantly evolving and rapidly developing discipline, such stability should be a matter for serious discussion and periodic re-evaluation. Moreover, the ACM/IEEE Computing Curriculum 2001 appears to downgrade this material into a unit rather than a full-fledged course. We believe that the relevance of the course is actually greater today than ever and this important issue needs intense discussions as well.

Program and proof designs are fundamental in computer science (CS). The designs involve the employment of various heuristics that may be considered rather inherent and natural, such as decomposition. Yet, not all heuristics are natural. One less natural, and rather unintuitive heuristic is that of reversing, in which a task is approached by reasoning backwards or viewing entities through "inverse lenses". One primary form of this heuristic is recursion. But, there are additional forms throughout the CS curriculum that are essential yet not underlined. In this paper we display these forms, underline their important role, and illustrate them in five core courses. In addition, we describe our experience with student difficulties due to unawareness and lack of competence with this heuristic, and offer preliminary guidelines for elaborating it during CS studies.

Abstraction has been the focus of many researches in mathematics education and to some extent in computer science education. Abstract thinking characterizes the theoretical foundations of computer science, where reduction is one important abstract thinking pattern. In a previous work, we discussed the issue of reductive thinking among high school students in relation to computational models - a theoretical unit. This unit requires abstract thinking in many aspects. Our findings in relation to reductive thinking showed that many students preferred direct, non-reductive solutions, even if reductive solutions could have significantly decreased the design complexity of the solution. This study motivated the current study where we examine the issue of reductive thinking among university students. The findings of this preliminary study are demonstrated by students' solutions to questions in assignments given in the computational models course. We found that even among university students in a very prestigious academic institution with very high entrance requirements abstraction is a real obstacle as reduction is not easily understood and used. This encourages us to further investigate this phenomenon.

We introduces the generalized idea of reduction in computer science, survey three papers that study reductive thinking of high-school and undergraduate students in various contexts of CS.

This paper describes research on the perception of undergraduate students of the concept of reduction. Specifically, based on an analysis of students' answers to questions addressing different CS topics, we present several findings regarding the ways in which undergraduate students conceive of and apply reduction. In addition to the research description and results, the paper discusses the role of reduction in CS and suggests several teaching applications.

Poster session 2. Reductive thinking is an important thinking pattern, one that characterizes the theory of computer science (CS), and which is relevant to many other areas of CS, such as algorithmic design. Essentially, solving a problem by reduction means transforming it into simpler problems (or problems for which the solution is already known), and constructing or deducing the solution to the original problem from the solutions to the new problems. Developing reductive thinking patterns is an important goal in any scientific discipline, and particularly in CS. [1st paragraph]

When dealing with a complex problem, solving it by reduction to simpler problems, or problems for which the solution is already known, is a common method in mathematics and other scientific disciplines, as in computer science and, specifically, in the field of computability. However, when teaching computational models (as part of computability) this topic is not usually explicitly emphasized. The authors believe that developing reductive thinking patterns is an important goal in any scientific discipline, and specifically in Computer Science (CS). Problems that deal with computational models can nicely serve to demonstrate and enable practice of such thinking patterns, especially if these problems are carefully chosen, and have a few possible reductive solutions. In this paper, the authors demonstrate this principle using a number of problems for two computational models: The finite automata model (representing finite state machines with no additional memory) and the pushdown automata model (representing finite state machines equipped with an infinite memory, which may be accessed according to the Last-In-First-Out principle.) Although these problems were used for high school students, appropriate problems can be defined that are suitable for college and university courses. (Contains 13 figures.)

Solving problems by reduction is an important issue in mathematics and science education in general (both in high school and in college or university) and particularly in computer science education. Developing reductive thinking patterns is an important goal in any scientific discipline, yet reduction is not an easy subject to cope with. Still, the use of reduction usually is insufficiently reflected in high school mathematics and science programs. Even in academic computer science programs the concept of reduction is mentioned explicitly only in advanced academic courses such as computability and complexity theory. However, reduction can be applied in other courses as well, even on the high school level. Specifically, in the field of computational models, reduction is an important method for solving design and proof problems. This study focuses on high school students studying the unit "computational models" - a unique unit, which is part of the new Israeli computer science high school curriculum. We examined whether high school students tend to solve problems dealing with computational models reductively, and if they do, what is the nature of their reductive solutions. To the best of our knowledge, the tendency to reductive thinking in theoretical computer science has not been studied before. Our findings show that even though many students use reduction, many others prefer non-reductive solutions, even when reduction can significantly decrease the technical complexity of the solution. We discuss these findings and suggest possible ways to improve reductive thinking.

One of the units in the relatively new high school CS curriculum which is being implemented in Israel is a theoretical unit on computational models. It includes deterministic and non-deterministic finite automata, regular and non-regular languages, closure properties of regular languages, pushdown automata, closure properties of context free languages, Turing machines, the Church-Turing thesis and the halting problem. This paper focuses on part of a study we conducted dealing with the achievements of high school students studying this unit. Specifically, this paper compares the achievements of students on the technical parts of this unit vs. its theoretical parts. We also examine the correlation between achievements of students studying the Computational Models unit, and two other factors: The students' previous computer-related background (not necessarily computer science) and the level on which they studied mathematics.

One of the units in the relatively new high school CS curriculum which is being implemented in Israel is a theoretical unit on computational models. It includes deterministic and non-deterministic finite automata, regular and non-regular languages, closure properties of regular languages, pushdown automata, closure properties of context free languages, Turing machines, the Church-Turing thesis and the halting problem. This paper focuses on part of a study we conducted dealing with the achievements of high school students studying this unit. Specifically, this paper compares the achievements of students on the technical parts of this unit vs. its theoretical parts. We also examine the correlation between achievements of students studying the Computational Models unit, and two other factors: The students' previous computer-related background (not necessarily computer science) and the level on which they studied mathematics.

The importance of reductive thinking in solving problems related to students ' studies is discussed. The development of reductive thinking patterns in early stages of students' studies is an important goal. Computational models can easily serve to demonstrate and enable practice of such thinking patterns. Closure properties are often used in a computational models course to solve proof problems.

One of the units in the relatively new high school CS curriculum which is being implemented in Israel is a theoretical unit on computational models. It includes deterministic and non-deterministic finite automata, regular and non-regular languages, closure properties of regular languages, pushdown automata, closure properties of context free languages, Turing machines, the Church-Turing thesis and the halting problem. This paper focuses on part of a study we conducted on the unit, dealing with the topic of non-determinism of finite automata. One of the aspects dealt with was how students perceived non-determinism. 339 students were given a relatively complicated regular language, and asked to construct a finite automaton that accepts this language. We found that many students did not choose the easiest way to solve the problem: Many students preferred to construct a deterministic automaton, even though constructing a non-deterministic automaton for the language is much simpler. We analyze and categorize the students' solutions, thus shedding some light on their perception of the abstract concept of non-determinism.

We report that the vanadium ligand L-Glu(γ)HXM potentiates the capacity of free vanadium ions to activate glucose uptake and glucose metabolism in rat adipocytes in vitro (by 4-5-fold) and to lower blood glucose levels in hyperglycemic rats in vivo (by 5-7-fold). A molar ratio of two L-Glu(γ)HXM molecules to one vanadium ion was most effective. Unlike other vanadium ligands that potentiate the insulinomimetic actions of vanadium, L-Glu(γ)HXM partially activated lipogenesis in rat adipocytes in the absence of exogenous vanadium. This effect was not manifested by D-Glu(γ)HXM. At 10-20 μM L- Glu(γ)HXM, lipogenesis was activated 9-21%. This effect was approximately 9- fold higher (140 ± 15% of maximal insulin response) in adipocytes derived from rats that had been treated with vanadium for several days. Titration of vanadium(IV) with L-Glu(γ)HXM led to a rapid decrease in the absorbance of vanadium(IV) at 765 nm, and ⁵¹V NMR spectroscopy revealed that the chemical shift of vanadium(IV) at -490 ppm disappeared with the appearance of a signal characteristic to vanadium(V) (-530 ppm) upon adding one equivalent of L- Glu(γ)HXM. In summary, L-Glu(γ)HXM is highly active in potentiating vanadium-activated glucose metabolism in vitro and in vivo and facilitating glucose metabolism in rat adipocytes in the absence of exogenous vanadium probably through conversion of trace intracellular vanadium into an active insulinomimetic compound. We propose that the active species is either a 1:1 or 2:1 L-Glu(γ)HXM vanadium complex in which the endogenous vanadium(IV) has been altered to vanadium(V). Finally we demonstrate that L-Glu(γ)HXM- and L- Glu(γ)HXM-vanadium-evoked lipogenesis is arrested by wortmannin and that activation of glucose uptake in rat adipocytes is because of enhanced translocation of GLUT4 from low density microsomes to the plasma membrane.

A Textbook for CS high school students (11th-12th grades), teaching a theoretical aspect of computer science. It covers the following computational models: finite automata (deterministic, partial deterministic, non-deterministic), pushdown automata (non-deterministic, deterministic), Turing machine. Regarding each model the following issues are discussed: limitations (what cannot be computed), closure properties, the computational power gained by adding non-determinism. The textbook discusses also the halting problem and the Church-Turing thesis. This is done at a level that corresponds to the students' age.

A teacher guide for the high-school CS textbook on computational models. It includes teaching guidelines, solutions to all the textbook exercises as well as additional solved exercises.