Knowledge tracing: Modeling the acquisition of procedural knowledge

This paper describes an effort to model students' changing knowledge state during skill acquisition. Students in this research are learning to write short programs with the ACT Programming Tutor (APT). APT is constructed around a production rule cognitive model of programming knowledge, called theideal student model. This model allows the tutor to solve exercises along with the student and provide assistance as necessary. As the student works, the tutor also maintains an estimate of the probability that the student has learned each of the rules in the ideal model, in a process calledknowledge tracing. The tutor presents an individualized sequence of exercises to the student based on these probability estimates until the student has mastered each rule. The programming tutor, cognitive model and learning and performance assumptions are described. A series of studies is reviewed that examine the empirical validity of knowledge tracing and has led to modifications in the process. Currently the model is quite successful in predicting test performance. Further modifications in the modeling process are discussed that may improve performance levels.     

Inducing High-Level Behaviors from Problem-Solving Traces Using Machine-Learning Tools

Many researchers consider interactive learning environments to be interesting solutions for overcoming the limits of classical one-to-many teaching methods. However, these environments should incorporate accurate representations of student knowledge to provide relevant guidance. In a problem-solving environment, one way to build and update this student model is model tracing, or using a detailed representation of cognitive skills to precisely follow what the student is doing. Some model-tracing tutors such as PAT (Personal Algebra Tutor) contain rules that the system can use to solve the problem and assess the student's solution.     

《程序设计》课程教学方法新探

针对当前《程序设计》课程教学中存在的问题,根据多年来从事该课程教学的经验,同时结合指导学生参加ACM国际大学生程序设计竞赛的经验,提出相应的改革措施,包括淡化语法,重视解题思路、解题方法的培养,利用单步执行程序帮助学生理解程序设计的相关知识,利用在线评测系统加强实践环节,调动学生上机实践的积极性。     

DISCOVER: AN INTELLIGENT DISCOVERY PROGRAMMING SYSTEM

Much of research in programming environments for novices has been polarized toward two opposite domains: guided programming environments and free programming environments. Intelligent programming tutors and systems that represent guided environments concentrate mainly on helping novices in acquiring programming skills through a series of problem-solving situations. Most of these systems tend to ignore the significance of a preproblem solving, dynamic, visualization-based, and free environment which would help novices in compiling an effective programming knowledge through a discovery-like process. Free programming environments, on the other hand, concentrate exclusively on helping novices to build correct programming knowledge through visible, exploratory, and free discovery environments. These systems generally tend to neglect the issue of supporting those aspects of intelligent diagnosis and tutoring, through which novices can transform their program knowledge into programming skill. A system has been developed called DISCOVER that occupies a unique niche between the two domains discussed above. The system emphasizes a synthesis-based framework which integrates free programming with guided programming features, and supports software visualization and immediacy of feedback to come up with an environment that facilitates learning programming through discovery and guidance. To assess the usefulness of the design framework presented in this paper, two pilot performance evaluations were conducted. The results provided a number of interesting insights into the implication of incorporating visualization and immediacy features, along with intelligent program diagnosis into the design of programming systems intended mainly for novices.     

Impact of Knowledge Representations on Problem-Oriented Learning in Online Environments

The objective of this study was to investigate the impact of knowledge representations on problem-oriented learning in online learning environments. The study compared the impact of knowledge map representation with traditional hierarchical representation with regard to learning memory and problem-solving performance. Twenty-nine students participated in an experiment in which they studied online materials with the goal of solving two programming problems (simple and complex). It was found that participants who used the hierarchical representation read in the depth-first sequence, whereas participants who used the knowledge map representation read in a sequence reflecting the system running mechanism implied by the graphical representation. In addition, participants who used the knowledge map representation had better memory of the learning content, especially about relations between knowledge nodes. When solving the complex problem, participants who used the knowledge map representation made a deeper analysis of the problem and had better problem-solving performance. These results were not significant in the simple problem-solving task.     

Effects of different ratios of worked solution steps and problem solving opportunities on cognitive load and learning outcomes

A crucial challenge for instructional designers is to determine the amount of support that is most beneficial for learning. This experiment investigated effects of different ratios of worked solution steps (high assistance) and to-be-solved problem steps (low assistance) on cognitive skill acquisition in geometry. High-school students (N = 125) worked on a geometry lesson in a Cognitive Tutor under five different ratios (from zero worked steps and five to-be-solved steps to four worked steps and one to-be-solved step). Effects on cognitive load and learning outcomes were assessed. We expected the effectiveness of different ratios to vary with the type of learning outcomes (i.e., procedural vs. conceptual knowledge) and the difficulty of the to-be-learned principles. Results showed that for procedural knowledge (but not for conceptual knowledge) problem solving alone was most beneficial for the acquisition of procedural knowledge related to an easy principle. For a difficult principle, no ratio of worked steps and problem solving showed an advantage over another. Problem solving induced more extraneous load than studying worked examples. Thus, in determining optimal amounts of guidance type of knowledge and difficulty of the single to-be learned knowledge chunks should be considered.     

LISP as a rapid prototyping environment: The Chinese tutor

LISP provides a powerful interactive environment that supports rapid prototyping of complex software. This has always been a main feature of the language, and one that has contributed to its widespread use for experimental applications. Recent years have also seen the development of LISP systems that provide performance comparable with, or better than, that of more traditional programming languages. The next logical step is to show that systems developed in LISP with a rapid-prototyping approach can also provide excellent performance. As an example of the suitability of LISP for rapid prototyping of efficient systems, this article presents a case study where a system was built in a Common Lisp environment out of a series of existing tools. Reliance on existing tools, as well as the interactive features typical of LISP, resulted in extremely rapid prototyping. The system, a computer-based tutor for beginner-level Chinese, was developed in less than three man-weeks. Very rapid development time, however, did not in any way sacrifice performance: the system's performance is quite good and comparable to that of ad hoc systems. This is true of both the interactive component of the program, i.e. the interface to the student, and the database component, which stores the system's knowledge about the Chinese language. The factors that contributed most to the short development time were the extensive reliance on existing tools, the use of an efficient knowledge representation language to implement most of the data structures, and the use of an integrated programming environment. All of these factors were in turn made possible, or at least greatly facilitated, by the choice of LISP as the programming language.     

Ability-training-oriented automated assessment in introductory programming course

Learning to program is a difficult process for novice programmers. AutoLEP, an automated learning and assessment system, was developed by us, to aid novice programmers to obtain programming skills. AutoLEP is ability-training-oriented. It adopts a novel assessment mechanism, which combines static analysis with dynamic testing to analyze student programs. It not only helps students to sufficiently test the programs, but also evaluates whether the programs meet the specification or not. AutoLEP encourages students to find and work through bugs, by providing automatic syntactic and structural checking, and immediate detailed feedback. This can improve students’ learning experience in programming and reduce the workload of the teaching staff. AutoLEP has been used in the C programming course at Harbin Institute of Technology and many other universities since 2004. The feedback on AutoLEP and its incorporation into the introductory programming course has been positive, both by students and teaching staff.     

A portable lisp compiler

The programming language LISP is usually implemented via an interpreter, and a compiler is added later as a LISP program. However, all such production compilers known to the authors produce explicit instructions for the given computer being used. This paper describes the development of a portable LISP compiler in the sense that only Standard LISP functions are used in its definition and the output is a sequence of abstract machine codes, easily mapped to instruction sequences on current computers. The resulting code is quite efficient, demonstrating once again the maxim that most compiler optimization is largely machine independent.     

The worked-example effect: Not an artefact of lousy control conditions

Recently it has been argued that the worked-example effect, as postulated by Cognitive Load Theory, might only occur when compared to unsupported problem-solving, but not when compared to well-supported or tutored problem-solving as instantiated, for example, in Cognitive Tutors. In two experiments, we compared a standard Cognitive Tutor with a version that was enriched with faded worked examples. In Experiment 1, students in the example condition needed less learning time to acquire a comparable amount of procedural skills and conceptual understanding. In Experiment 2, the efficiency advantage was replicated. In addition, students in the example condition acquired a deeper conceptual understanding. The present findings demonstrate that the worked-example effect is indeed robust and can be found even when compared to well-supported learning by problem-solving.     

Automatic program debugging for intelligent tutoring systems

Program debugging is an important part of the domain expertise required for intelligent tutoring systems that teach programming languages. This article explores the process by which student programs can be automatically debugged in order to increase the instructional capabilities of these systems. The research presented provides a methodology and implementation for the diagnosis and correction of nontrivial recursive programs. In this approach, recursive programs are debugged by repairing induction proofs in the Boyer-Moore logic. The induction proofs constructed and debugged assert the computational équivalence of student programs to correct exemplar solutions. Exemplar solutions not only specify correct implementations but also provide correct code to replace buggy student code. Bugs in student code are repaired with heuristics that attempt to minimize the scope of repair. The automated debugging of student code is greatly complicated by the tremendous variability that arises in student solutions to nontrivial tasks. This variability can be coped with, and debugging performance improved, by explicit reasoning about computational semantics during the debugging process. This article supports these claims by discussing the design, implementation, and evaluation of Talus, an automatic debugger for LISP programs, and by examining related work in automated program debugging. Talus relies on its abilities to reason about computational semantics to perform algorithm recognition, infer code teleology, and to automatically detect and correct nonsyntactic errors in student programs written in a restricted, but nontrivial, subset of LISP. Solutions can vary significantly in algorithm, functional decomposition, role of variables, data flow, control flow, values returned by functions, LISP primitives used, and identifiers used. Solutions can consist of multiple functions, each containing multiple bugs. Empiricial evaluation demonstrates that Talus achieves high performance in debugging widely varying student solutions to challenging tasks.     

Effects of an integrated concept mapping and web-based problem-solving approach on students' learning achievements,perceptions and cognitive loads

Although students could effectively search for web data with proper keywords and select web pages related to the studied core issue, however summarizing or organizing the retrieved information remains a difficult task for them. Concept mapping is known to be an effective knowledge construction tool for helping learners organize important concepts related to a core issue. To address the problem, an integrated concept mapping and web-based problem-solving environment, CM-Quest, has been developed; moreover, an experiment has been conducted to evaluate the effectiveness of the approach on students' learning performance, learning satisfaction and cognitive load in an elementary school social studies course. The results show that the concept map-integrated approach can significantly enhance the students' web-based problem-solving performance, although the students showed lower degrees of technology acceptance and learning satisfaction in comparison with the conventional web-based problem-solving approach. Moreover, it is found that the students in the concept mapping group revealed higher cognitive loads than those in the control group, which could be the factor contributing to the lower technology acceptance degree and learning satisfaction. As a consequence, it is concluded that the integrated concept mapping and web-based problem-solving approach is helpful to students in guiding them to learn in a more effective way. On the other hand, it remains an open issue to find a suitable way of integrating concept maps into the learning process without introducing too much extra cognitive load so as to promote students' acceptance degree of using technology for better learning.     

面向能力培养的网络编程技术课程教学方法探讨

针对网络编程技术课程的具体特点和要求,在剖析课程内容、整理教学实践经验、总结应用需求的基础上,提出以课程项目为驱动、以问题为线索组织教学内容,展开专题性与综合性相结合的实践教学,综合课程考核方法,以此提高学生对网络编程技术课程的学习兴趣,提升学生问题求解能力。     

A system which automatically improves programs

Summary Here we give methods of mechanically converting programs that are easy to understand into more efficient ones, converting recursion equations using high level operations into lower level flowchart programs.The main transformations involved are (i) recursion removal (ii) eliminating common subexpressions and combining loops (iii) replacing procedure calls by their bodies (iv) introducing assignments which overwrite list cells no longer in use (compiletime garbage collection).The operations we use are based on the POP-2 language, Burstall, Collins and Popplestone [1]. The main features to note are that hd is the LISP car, tl the LISP cdr and concat joins two lists (the LISP append).     

A drawing and multi-representational computer environment for beginners’ learning of programming using C: Design and pilot formative evaluation

This paper presents both the design and the pilot formative evaluation study of a computer-based problem-solving environment (named LECGO: Learning Environment for programming using C using Geometrical Objects) for the learning of computer programming using C by beginners. In its design, constructivist and social learning theories were taken into account. The general design has taken into consideration models of the learning process and subject matter as well as potential learner behaviour in dealing with fundamental tasks. The main emphasis has been placed on the role of: (a) multiple external representations in student learning, (b) motivation, through performing problem-solving activities taken from the familiar and meaningful context of drawing, using simple geometrical objects, (c) the active participation of students in their own learning by using hands-on experience, (d) appropriate feedback on the actions taken by students, to aid their self-correction, and (e) holistic, activity-based, multi-media, multi-representational and multi-layered content for the learning of basic concepts of programming using C. LECGO was pilot evaluated in the field through a qualitative and comparative study where nine 12th grade (18-year-old) students participated. In fact, students faced three similar yet not identical sets of four tasks across three learning environments, namely; paper and pencil (p–p), Turbo C and LECGO. The data emerging from this field evaluation study indicates that students gain better results within LECGO than in both the p–p environment and the typical programming environment of Turbo C, while performing similar activities.     

Program Reusability through Program Transformation

How can a program written in pure applicative LISP be reused in a Fortran environment? One answer is by automatically transforming it from LISP into Fortran. In this paper we discuss a practical application of this technique-one that yields an efficient Fortran program. We view this process as an example of abstract programming, in which the LISP program constitutes an abstract specification for the Fortran version. The idea of strategy-a strategy for getting from LISP to Fortran-is basic to designing and applying the transformations. One strategic insight is that the task is easier if the LISP program is converted to ``recursive' Fortran, and then the recursive Fortran program is converted to nonrecursive standard Fortran. Another strategic insight is that much of the task can be accomplished by converting the program from one canonical form to another. Developing a strategy also involves making various implementation decisions. One advantage of program transformation methodology is that it exposes such decisions for examination and review. Another is that it enables optimizations to be detected and implemented easily. Once a strategy has been discovered, it can be implemented by means of rewrite-rule transformations using the TAMPR program transformation system. The transformational approach to program reuse based on this strategy has a measure of elegance. It is also practical-the resulting Fortran program is 25 percent faster than its compiled LISP counterpart, even without extensive optimization.     

SeqDynamics: Visual Analytics for Evaluating Online Problem-solving Dynamics

Problem-solving dynamics refers to the process of solving a series of problems over time, from which a student's cognitive skills and non-cognitive traits and behaviors can be inferred. For example, we can derive a student's learning curve (an indicator of cognitive skill) from the changes in the difficulty level of problems solved, or derive a student's self-regulation patterns (an example of non-cognitive traits and behaviors) based on the problem-solving frequency over time. Few studies provide an integrated overview of both aspects by unfolding the problem-solving process. In this paper, we present a visual analytics system named SeqDynamics that evaluates students ‘problem-solving dynamics from both cognitive and non-cognitive perspectives. The system visualizes the chronological sequence of learners’ problem-solving behavior through a set of novel visual designs and coordinated contextual views, enabling users to compare and evaluate problem-solving dynamics on multiple scales. We present three scenarios to demonstrate the usefulness of SeqDynamics on a real-world dataset which consists of thousands of problem-solving traces. We also conduct five expert interviews to show that SeqDynamics enhances domain experts’ understanding of learning behavior sequences and assists them in completing evaluation tasks efficiently.     

Case-based teaching using the Laboratory Animal System for learning C/C++ programming

Teachers and students often consider learning programming a difficult pursuit. Face-to-face learning alone cannot provide effective teaching or efficient solutions for learning. A case teaching model can make students active in programming courses, even as it relies on solid learning theory and pedagogical strategies. This paper reports a study based on a case teaching model in C/C++ programming. The Laboratory Animal System (LAS) is a standalone case for management of laboratory animals. This paper includes an overview of LAS architectural design and user interface by C/C++ and presents the design, implementation, and evaluation of the model, as well as its implications for learning computer programming. The case method provides an interactive learning environment for students. Based on a survey of student feedback, students can learn C/C++ programming and gain knowledge more quickly and effectively using the case teaching model than through some traditional methods of teaching.