David Ginat

Pattern-oriented instruction and its influence on problem decomposition and solution construction

Novices often experience difficulties in problem analysis and solution construction. Pattern-oriented instruction (POI) is a pedagogical approach based on incorporating patterns into instruction design. It is well-grounded in cognitive theories concerning knowledge construction and organization as well as the acquisition of expertise in problem solving. We show that the incorporation of algorithmic patterns through POI may enhance the construction of algorithmic problem-solving knowledge. Findings of a comparative research study showed that novices who studied according to the POI approach exhibited better problem-solving competence than those who studied in a traditional manner. Specifically, they were more competent in problem decomposition and solution construction.

Striving for mathematical thinking

Computer science and software engineering are young, maturing disciplines. As with other mathematically based disciplines, such as the natural sciences, economics, and engineering, it takes time for the mathematical roots to grow and flourish. For computer science and software engineering, others have planted these seeds over many years, and it is our duty to nurture them. This working group is dedicated to promoting mathematics as an important tool for problem-solving and conceptual understanding in computing.

A tight amortized bound for path reversal

Abstract Path reversal is a form of path compression used in a disjoint set union algorithm and a mutual exclusion algorithm. We derive a tight upper bound on the amortized cost of path reversal.

Learning from wrong and creative algorithm design

We all are aware of the relevance of examining a task from diverse angles. We also are aware of the potential relevance of learning from ones mistakes. Yet computer science (CS) textbooks and teaching materials fall short in embedding these two notions. In this paper, we present an approach of elaborating divergent thinking in algorithm design, while capitalizing on erroneous solutions. Using a collected set of non-routine algorithmic tasks, we developed and applied a scheme of class activities, in which initial faulty solutions (due to novice tendencies) are carefully examined, and their falsifying inputs and characteristics are used for creative reasoning that yields fruitful outcomes. We present and illustrate our activities, refer to their cognitive aspects, and describe our experience with applying them in (an Introduction-to-Algorithms) class.

Early Algorithm Efficiency with Design Patterns

Algorithm efficiency is a fundamental computer science concept encapsulating the core topic of algorithm complexity. While complexity is expressed in formal measures such as ‘Big O’, efficiency can be denoted in rather flexible terms. Thus, unlike complexity, which is postponed in the introduction of programming (due to its formal measures), efficiency can be introduced early. Unfortunately, the strong link between efficiency and complexity yields a delayed introduction of efficiency. This is unnecessary and results in reduced student perspective of basic programming considerations. I present an Efficiency-Early Approach in which efficiency of algorithms is introduced early, gradually, using simple measuring terms. The approach emphasizes capitalization on problem characteristics and utilization of design patterns. I illustrate the approach with gradually-more-subtle algorithmic tasks, and assess different levels of their solutions. The more advanced tasks are colorful and rather unfamiliar. The different solution levels represent results I experienced in implementing the approach with highschool computer science students. The implementation raised student awareness of problem characteristics, augmented their design pattern repertoires, and enhanced their efficiency perspective. Improvement in mathematical insight was experienced with the average and better students.

Interleaved pattern composition and scaffolded learning

One of the essential skills required in the design of computer programs is the composition of design patterns in an interleaved way. We expect both beginners and senior students to demonstrate competence with this skill. Are they competent? Not quite. We found that both novices and seniors demonstrate disturbing difficulties with interleaved pattern composition. In order to address these difficulties, we developed a scaffolding instruction approach, which we applied with students. We display our findings, our approach, and the approach implementation.

Do senior CS students capitalize on recursion

CS students learn and practice recursion in CS1, Data-Structures, Introduction-to-Algorithms, and additional courses throughout the curriculum. Previous studies revealed difficulties of CS1 students with the concept and the construct of recursion. What about advanced students? They may well understand the concept and the construct of recursion; but do they invoke and utilize recursion as a problem solving means? The paper examines this aspect, with senior CS students. The students were given three algorithmic tasks, for which the suitable solution approach was recursive. The student solutions and explanations demonstrate very limited capitalization on recursion as a problem solving means. We discuss the findings and suggest pedagogical implications for teaching.

Misleading intuition in algorithmic problem solving

This paper presents a study of misleading intuition in the domain of algorithmic problem solving. I noticed incorrect intuitive solutions to challenging algorithmic problems and interviewed students on their solutions. The students arrived at an erroneous conviction rather rapidly and demonstrated overconfidence and reinforcement of their incorrect ideas when presented with new evidence. I present two colorful and unfamiliar algorithmic challenges posed to the students, describe and discuss my experience, and offer some suggestions for reducing the effect of misleading intuition.

Loop invariants and mathematical games

The concept of combining loop invariants with algorithm analysis and design is a significant programming tool. However, teaching this concept is not easy. One way of motivating and supporting the introduction of such a concept, is by illustrating it with attractive examples. In this paper we describe how to illustrate it with mathematical games. In our description, we emphasize the links between heuristic search strategies, pattern exploration, induction, and invariant construction.

SOLO Taxonomy for Assessing Novices' Algorithmic Design

We present the utilization of the educational SOLO taxonomy for assessing algorithmic features of introductory programming. The SOLO taxonomy was recently studied by CS research educators, with respect to code reading and code writing. Most of the studies focused on code reading. In this paper we offer a framework of SOLO utilization for assessing basic algorithmic design features of code writing. Our novelty stems from focusing on: selection, flexible manipulation, and composition of basic design patterns, as well as on capitalization on unfolded task characteristics. We specify SOLO levels with respect to algorithmic design, and relate to common errors. We display our findings of applying the suggested framework in an ordered study with CS1 students.