Mordechai Ben-Ari

Constructivism in computer science education

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

The temporal logic of branching time

SummaryA temporal logic is defined which contains both linear and branching operators. The underlying model is the tree of all possible computations. The following metatheoretical results are proven: 1) an exponential decision procedure for satisfiability; 2) a finite model property; 3) the completeness of an axiomatization.

Visualizing programs with Jeliot 3

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.

Learning computer science concepts with Scratch

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.

The Jeliot 2000 program animation system

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.

A long-term investigation of the comprehension of OOP concepts by novices

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.

Learning computer science concepts with scratch

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.

Habits of programming in scratch

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.

On understanding the statics and dynamics of object-oriented programs

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.

Deterministic propositional dynamic logic: Finite models, complexity, and completeness☆

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 2 cn and the size of the model is bounded by n 2 · 4 n , 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.