Immediate feedback has a positive effect on the performance of a student practising a procedural skill in exercises. Giving feedback to a number of students is labour-intensive for a teacher. To alleviate this, many electronic exercise assistants have been developed. However, many of the exercise assistants have some limitations in the feedback they offer. We have a feedback engine that gives semantically rich feedback for several domains (like logic, linear algebra, arithmetic), and that can be relatively easy extended with new domains. Our feedback engine needs to have knowledge about the domain, how to reason with that knowledge (i.e. a set of rules), and a specified strategy. We offer the following types of feedback: correct/incorrect statements, distance to the solution, rulebased feedback, buggy rules, and strategy feedback. We offer the feedback functionality in the form of light-weight web services. These services are offered using different protocols, for example

Abstract not found

Abstract. In these lectures we will introduce an interactive system that supports writing simple functional programs. Using this system, students learning functional programming: – develop their programs incrementally, – receive feedback about whether or not they are on the right track, – can ask for a hint when they are stuck, – see how a complete program is stepwise constructed, – get suggestions about how to refactor their program. The system itself is implemented as a functional program, and uses fundamental concepts such as rewriting, parsing, strategies, program transformations and higher-order combinators such as the fold. We will introduce these concepts, and show how they are used in the implementation of the interactive functional programming tutor. 1

Abstract. Mathematical Knowledge Management (MKM), as a field, has seen tremendous growth in the last few years. This period was one where many research threads were started, and the field was defining itself. We believe that we are now in a position to use the MKM body of knowledge as a means to define what MKM is, what it worries about, etc. In this paper, we review the literature of MKM and gather various metadata from these papers. After offering some definitions surrounding MKM, we analyse the metadata we have gathered from these papers, in an effort to cast more light on the field of MKM and its evolution.

ActiveMath is an intelligent e-Learning system that exhibits some Semantic Web features. Its content knowledge representation is a semantic XML dialect for mathematics; semantic search is enabled; some of its components work as a web service and, vice versa, it employs certain foreign web services, e.g., for diagnostic purposes. In this paper, we describes features which have not been presented at all or only superficially in previous publications.

Abstract: An exercise assistant is a tool that supports students learning procedural skills, such as solving systems of linear equations, or rewriting a logic expression to disjunctive normal form. The domain reasoner is the component of an exercise assistant that deals with tasks that depend on the semantics of a particular domain, for example the rules that may be applied, or the procedure that should be followed when solving an exercise. An exercise assistant typically has multiple domain reasoners, and the behavior of each of these is, to a large extent, determined by the domain. Generic programming techniques claim to reduce code duplication, to make it easier to change the structure of data, and to provide implementations of many useful functions on most datatypes. There are many libraries for generic programming, all with different datatype support, expressiveness, and ease of use. While a lot of effort has been put into developing new libraries in the past few years, there are few examples of real-life applications of generic programming. In this paper we describe our experience with applying generic programming techniques to our domain reasoners implemented in Haskell. We have used the Uniplate, Multirec, and Regular generic programming libraries. We assess and compare the resulting generic domain reasoners with each other and with the initial, non-generic version, using the software quality factors of the ISO 9126 international standard.

Abstract: An exercise assistant is a tool that supports students learning procedural skills, such as solving systems of linear equations, or rewriting a logic expression to disjunctive normal form. The domain reasoner is the component of an exercise assistant that deals with tasks that depend on the semantics of a particular domain, for example the rules that may be applied, or the procedure that should be followed when solving an exercise. An exercise assistant typically has multiple domain reasoners, and the behavior of each of these is, to a large extent, determined by the domain. Generic programming techniques claim to reduce code duplication, to make it easier to change the structure of data, and to provide implementations of many useful functions on most datatypes. There are many libraries for generic programming, all with different datatype support, expressiveness and ease of use. While a lot of effort has been put into developing new libraries in the past few years, there are few examples of real-life applications of generic programming. In this paper we describe our experience with applying generic programming techniques to our domain reasoners implemented in Haskell. We have used the Uniplate, Multirec, and Regular generic programming libraries. We assess and compare the resulting generic domain reasoners with each other and with the initial, non-generic version, using the software quality factors of the ISO 9126 international standard.

Programming exercise assessment tools alleviate the task of teachers, and increase consistency of markings. Many programming exercise assessment tools are based on testing. A test-based assessment tool for programming exercises cannot ensure that a solution is correct. Moreover, it is difficult to test if a student has used good programming practices. This is unfortunate, because teachers want students to adopt good programming techniques. We propose to use strategies, in combination with program transformations, as a foundation for functional programming exercise assessment. Expert knowledge, in the form of model solutions, can be expressed as programming strategies. Using these strategies we can guarantee that a student program is equivalent to a model solution, and we can report which solution strategy has been used to solve the programming problem.

With the globalization in education, bridging cultural differences by making course material more accessible and adaptable to individual user needs becomes an important goal. In this paper we attack this goal for the field of mathematics where knowledge is abstract, highly structured, and extraordinary interlinked. Modern representation formats like our OMDOC format allow us to capture, model, relate, and represent mathematical learning objects and thus make them context-aware and machine-adaptable to the respective learning contexts. But to make mathematical knowledge accessible to learners of diverse cultural backgrounds we also need to model mathematical practice. In this paper, we show that many practices of mathematical communities can already be modeled in OMDOC and outline extensions to support further ones. We have implemented a collection of services that allow applications to interpret and manage OMDOC and its practice representations as well as to adapt OMDOC for users and communities. These services have been integrated into our prototype E-Learning platform panta rhei to demonstrate how systems can improve the accessibility of mathematical E-Learning materials.

Term-rewriting systems can be expressed as generic programs parameterised over the shape of the terms being rewritten. Previous implementations of generic rewriting libraries require users to either adapt the datatypes that are used to describe these terms or to specify rewrite rules as functions. These are fundamental limitations: the former implies a lot of work for the user, while the latter makes it hard if not impossible to document, test, and analyse rewrite rules. In this report, we demonstrate how to overcome these limitations by making essential use of type-indexed datatypes. Our approach is lightweight in that it is entirely expressible in Haskell with GADTs and type families and can be readily packaged for use with contemporary Haskell distributions. 1