Informatics in Education

Teaching software engineering (SWE) as a core computer science course (ACM, 2013) is a challenging task. The challenge lies in the emphasis on what a large-scale software means, implementing teamwork, and teaching abstraction in software design while simultaneously engaging students into reasonable coding tasks. The abstraction of the system design is perhaps the most critical and theoretical part of the course and requires early engagement of the students with the necessary topics followed by implementation of the abstract model consistently. Normally, students would take such courses in the undergraduate curriculum sequence after data structures and/or object-oriented design/programming. Therefore, they would be able to learn about systematic modeling of software as a system. In this work, we address how to facilitate the teaching of SWE by introducing abstract modeling. Furthermore, functional decomposition is reviewed as a critical component which in turn, requires understanding of how different tasks are accomplished by enterprise software. Combining such pieces with concepts of architecture and design patterns of software provides foundational knowledge for students to be able to navigate around enterprise software in the real world.

The notion of ''don't care'', that encapsulates the unimportance of which of several scenarios will occur, is a fundamental notion in computer science. It is the core of non-determinism; it is essential in various computational models; it is central in distributed and concurrent algorithms; and it also is relevant in sequential, deterministic algorithms. It is a valuable tool in algorithmic problem solving. Yet, in the teaching of (deterministic) algorithms it is not made explicit, and left unexplored. Its implicit exposition yields limited student invocations and limited student comprehension upon its utilization. These phenomena are also due to its rather unintuitive ''black-box'' characteristic. In this paper, we illuminate and elaborate on this notion with six algorithmic illustrations, and describe our experience with novice difficulties with respect to this notion.

For over a decade, a declarative approach to problem solving based on the use of abstract data types (ADTs) has been taught to high-school students as part of the logic programming instructional unit. We conducted a study aimed at assessing students' problem-solving processes when utilizing ADTs. The findings indicated that students' strategies that diverged from the conceptual model often cause the students to develop incorrect programs. Specifically, students have difficulties in establishing correct mapping between the problem and its abstract model - the corresponding ADT, and in establishing proper connectivity between layers of abstraction related to different stages of the problem-solving processes (e.g., between distinct programming modules). These difficulties are apparently associated with general difficulties that novices encounter when learning programming, and with the cognitive load encountered when dealing with high levels of abstraction. With the intention to reduce student difficulties, we suggest using an instructional approach designed to gradually educate the students toward attaining proficiency as ``problem solvers'' through the use of integrative knowledge and autonomous problem-solving techniques. This approach should be further evaluated regarding its feasibility and applicability to reducing students' difficulties in dealing with abstraction processes.

In many occasions, the text describing an algorithmic task may entail a rather intuitive, operational solution scheme. Yet, such a scheme may not necessarily be efficient or correct. Nevertheless, novices demonstrate tendencies to hastily design their solutions that way, and avoid seeking insightful patterns, which may yield better solutions. In this paper, we name and shed light on this theme, and illustrate the essential importance of elaborating insightful patterns, which one may assimilate as general problem solving notions.

Abstract thinking is a vital skill when learning computer science. Object technology and the concepts it is based upon make this skill even more crucial. However, previous research works show that students in top universities as well as experienced practitioners in industry encounter difficulties in thinking in abstract terms while practicing object oriented development. In this paper we suggest an iterative teaching methodology for supporting students in learning object oriented concepts. The suggested methodology is based on familiarizing students with modeling languages and tools at the early stages of their learning and iterating between model and code. We theoretically examine the contribution of modeling languages, in particular UML, to abstract thinking and consequently to the understanding of object oriented concepts and present some observations acquired during a trial execution of this methodology in a university course.