In 2012, the authors took responsibility for a CS1 course with 45 students. This experience report reviews the subsequent 10-year learning process of engaging undergraduate students to facilitate small-group teaching and to design and develop an online learning environment to conduct what became our university's flagship CS1 course, currently enrolling 749 students. The course inherited an emphasis on small-group learning from its role model, MIT's 6.001. The size of the learning groups is limited to eight students per group, which currently requires a team of 105 student facilitators. The resulting need for student engagement and scaling motivated the development of a new web-based programming environment and assessment management system custom-made for the course. The system was conceived, designed, and implemented by students of the course, which provided the glue for building a sustainable and scalable community of learners, educators, and student software developers. This experience report describes the pedagogic approach, the course structure, and software system to accommodate the needs of this community. A qualitative and quantitative analysis of the impact of the course over the last four years provides evidence for its efficacy. We hope that this report serves as inspiration for similar large-scale pedagogic efforts that bring learners, educators, and student developers together to form sustainable and scalable learning communities.

The Source Academy is a community-built immersive online environment for learning computing with the book Structure and Interpretation of Computer Programs (SICP). An interactive version of the textbook is integrated into the system, and the programming environment of the Source Academy allows learners to focus on SICP-specific sublanguages of JavaScript (Python and Scheme versions in preparation). The environment includes tools to support SICP's mental models for computational processes and data, including a stepper that animates the substitution model of Chapter 1, a data visualizer that supports the box-and-pointer diagrams of Chapter 2, and a visualizer for the environment model of Chapter 3.

In teaching university entry-level calculus, it proved useful to distinguish early from late transcendentals depending on the time at which transcendentals such as the exponential and logarithmic functions are introduced. I suggest we pose analogous "early X or late X" questions for first-year computer science courses. I propose a tentative list of concepts for which the "early or late" question might be worthy a discussion and argue that the approach allows us to pay attention to pedagogical choices rather than the choice of the programming language for CS1 and CS2.

We propose a difficulty model for generating questions across formal domains according to the difficulty level provided by the user. Our model is interactive and adaptive to user input. The model uses predefined factors for measuring the difficulty and a user defines the difficulty level by ordering these factors. We use lexicographical ordering to compare the difficulty of questions based on a user-defined ordering of factors and a concomitant algorithm for handling these factors. Further, we provide a feature called scenario guidance, which allows users to change the scenario at run time. We develop a software using the proposed model, which generates new questions according to a user-defined difficulty level. In order to evaluate the proposed framework, we conducted a pilot test of the software, in which teachers generate questions according to their chosen desired input including the difficulty level. The results show that the system is effective, helpful and robust. Overall, the framework shows promising benefits for teachers and organizations involved in setting questions for standardized tests.

10.5220/0004947904670472

10.5220/0004795300140025

We extend our previously proposed framework that combines a combinatorial approach, pattern matching and automated deduction to generate geometry questions which, directly or indirectly, require finding the congruent regions formed by the intersection of geometric objects. The extension involves proposing a knowledge representation for regions and a rule-based algorithm for generation of region-based knowledge representation. In addition, several algorithms such as circle/arc projection to straight line (s) are proposed to avoid numerical reasoning for proving congruent regions, making the solution eligible for high school geometry domain. Furthermore, we propose the integration of this framework with our previously proposed framework to generate questions involving both implicit construction and congruent regions. The system is able to generate the solution (s) of the questions for their validation. Such a system would help teachers to quickly generate large numbers of questions based on several properties of geometric objects such as length, angle, area and perimeter. Students can explore, revise and master specific topics covered in classes and textbooks based on generated questions. This system may also help standardize tests such as Primary School Leaving Exam (PSLE), GMAT and SAT. Our methodology uses (i) a combinatorial approach for generating geometric figures (ii) Pattern matching and rule-based approach for region generation (iii) automated deduction for checking equality of properties of geometric objects (iv) linear equation solver to generate new questions and solutions. By combining these methods, we are able to generate questions involving finding or proving congruence relationships between the regions generated by the geometric objects based on a various specifications such as objects and concepts. Experimental results show that a large number of questions can be generated in a short time. A survey shows that the generated questions and the solutions are useful and fulfills the high school criteria.

Practical optimization problems often have objective functions that cannot be easily calculated. As a result, comparison-based algorithms that solve such problems use comparison functions that are imperfect (i.e. they may make errors). Machine learning algorithms that search for game-playing programs are typically imperfect comparison algorithms. This paper presents M2ICAL, an algorithm analysis tool that uses Monte Carlo simulations to derive a Markov chain model for imperfect comparison algorithms. Once an algorithm designer has modeled an algorithm using M2ICAL as a Markov chain, it can be analyzed using existing Markov chain theory. Information that can be extracted from the Markov chain include the estimated solution quality after a given number of iterations; the standard deviation of the solutions' quality; and the time to convergence.

Evolutionary processes have emerged as the defining feature of "life" in artificial life (Alife). When studying the behavior of a particular Alife form, the question naturally arises, whether a particular run of an Alife experiment exhibits evolutionary behavior or not. This paper presents the observer framework, a formal framework for answering this question, based upon the notion of observations made in the Alife model at hand. Starting with defining entities and their relationships observed during the runs, the framework prescribes a series of definitions (decisions) that the observer of the Alife form needs to make, followed by axioms (conditions) that must be met in order to establish evolutionary behavior in particular runs. We use the example of cellular automata based Langton loops to illustrate the observer framework, and suggest directions for further Alife research, based upon the framework design and the case study analysis.

Oz is a multiparadigm language that supports logic programming as one of its major paradigms. A multiparadigm language is designed to support different programming paradigms (logic, functional, constraint, object-oriented, sequential, concurrent, etc.) with equal ease. This paper has two goals: to give a tutorial of logic programming in Oz; and to show how logic programming fits naturally into the wider context of multiparadigm programming. Our experience shows that there are two classes of problems, which we call algorithmic and search problems, for which logic programming can help formulate practical solutions. Algorithmic problems have known efficient algorithms. Search problems do not have known efficient algorithms but can be solved with search. The Oz support for logic programming targets these two problem classes specifically, using the concepts needed for each. This is in contrast to the Prolog approach, which targets both classes with one set of concepts, which results in less than optimal support for each class. We give examples that can be run interactively on the Mozart system, which implements Oz. To explain the essential difference between algorithmic and search programs, we define the Oz execution model. This model subsumes both concurrent logic programming (committed-choice-style) and search-based logic programming (Prolog-style). Furthermore, as consequences of its multiparadigm nature, the model supports new abilities such as first-class top levels, deep guards, active objects, and sophisticated control of the search process. Instead of Horn clause syntax, Oz has a simple, fully compositional, higher-order syntax that accommodates the abilities of the language. We give a brief history of Oz that traces the development of its main ideas and we summarize the lessons learned from this work. Finally, we give many entry points into the Oz literature.

Constraint programming (CP) systems are useful for solving real-life combinatorial problems, such as scheduling, planning, rostering and routing problems. The design of modern CP systems has evolved from a monolithic to an open design in order to meet the increasing demand for application-specific customization. It is widely accepted that a CP system needs to balance various design factors such as efficiency versus customizability and flexibility versus maintenance. This paper captures our experience with using different software engineering approaches in the development of constraint programming systems. These approaches allow us to systematically investigate the different factors that affect the performance of a CP system. In particular we review the application of reuse techniques, such as toolkits, framework and patterns, to the design and implementation of a finite-domain CP system.

We goal of the work is to derive four-voice music pieces from given musical plans, which describe the harmonic flow and the intentions of a desired composition. We developed the experimentation platform COMPOzE for intention based composition. COMPOzE is based on constraint programming over finite domains of integers. We argue that constraint programming provides a suitable technology for this task and that the libraries and tools available for the constraint programming system Oz effectively support the implementation of COMPOzE. This work links the research areas of automatic music composition on one hand and finite domain constraint programming on the other, and contributes the tool COMPOzE, which practically demonstrates the potential of constraint programming to open up new areas of application for automatic music composition.