Nada Sharaf

Visualization of CHR through Source-to-Source Transformation

In this paper, we propose an extension of Constraint Handling Rules (CHR) with dierent visualization features. One feature is to visualize the execution of rules applied on a list of constraints. The second feature is to represent some of the CHR constraints as objects and visualize the effect of CHR rules on them. To avoid changing the compiler, our implementation is based on source-to-source transformation. 1998 ACM Subject Classification I.2.2 Automatic Programming, D.3.2 Language Classifications

CHRAnimation: An Animation Tool for Constraint Handling Rules

Visualization tools of different languages offer its users with a needed set of features allowing them to animate how programs of such languages work. Constraint Handling Rules (CHR) is currently used as a general purpose language. This results in having complex programs with CHR. Nevertheless, CHR is still lacking on visualization tools. With Constraint Handling Rules (CHR) being a high-level rule-based language, animating CHR programs through animation tools demonstrates the power of the language. Such tools are useful for beginners to the language as well as programmers of sophisticated algorithms. This paper continues upon the efforts made to have a generic visualization platform for CHR using source-to-source transformation. It also provides a new visualization feature that enables viewing all the possible solutions of a CHR program instead of the don’t care nondeterminism used in most CHR implementations.

A Rule-Based Approach for Animating Java Algorithms

Over the past years, visualization of programs has been widely applied. Algorithm animation was proven to aid in teaching and learning. It provides a convenient medium for beginners to a programming language by giving them the ability to visually discover how their programs are running. It also provides experts of a language with a means to have a visual trace utility. Lately, a new approach for adding visualization features into Constraint Handling Rules (CHR) programs was proposed. The new methodology was a dynamic one able to animate different types of algorithms. The work in this paper aims at introducing a revised extension that is able to embed visualization features into Java programs. With the new extension, Java algorithms could be animated without the need of doing any modifications to the code. In addition, the provided technique is still a general one able to animate different kinds of algorithms.

Towards the Implementation of a Source-to-Source Transformation Tool for CHR Operational Semantics

Constraint Handling Rules (CHR) is a high-level committed-choice language based on multi-headed and guarded rules. Over the past decades, several extensions to CHR and variants of operational semantics were introduced. In this paper, we present a generic approach to simulate the execution of a set of different CHR operational semantics. The proposed approach uses source-to-source transformation to convert programs written under different CHR operational semantics into equivalent programs in the CHR refined operational semantics without the need to change the compiler or the runtime system.

MiniColon; Teaching Kids Computational Thinking Using an Interactive Serious Game

Computer science is about learning how to think. It is applicable to everything. Most industries in the 21\(^{st}\) century are directed towards digitized processes using up-to-date technologies. This increases the need for students to know how these technologies work, especially with the availability of smart and handy devices. As a preliminary step to learning programming, students should learn basics of logical and computational thinking. Computational thinking compromises the skills, concepts, and behaviors used to solve problems. Some visual platforms, such as Scratch and Alice [6, 17], were introduced to teach children programming. The platform introduced in this paper aims at teaching young children (in the age range of 8–9 years old) the preliminary concepts of programming including sequential blocks, conditional blocks, and iterative blocks. This is achieved through an interactive, gesture-based game, where the Kinect Sensor device is used to control the gameplay instead of playing it using a normal PC. The game was tested using a between-group experimental model with two subgroups; an experimental group and a control group. The experimental group used the game whereas the control group was taught using a traditional educational method. The results showed a significant difference between the two groups with a P-value of < 0.05 for both the learning gain and the engagement level.

A Rule-Based Approach for Automatic Interaction Detection and Annotation

The paper introduces an approach that allows for detecting interaction with a graphical display in a rule-based declarative approach. It also introduces the possibility of connecting the interaction to a specific animation step to be performed. The two approaches were embedded into an animation system to aid in teaching algorithms.

CHR in Action

Constraint Handling Rules CHR has expanded its application range over the past few years to include different algorithms rather than only constraint solvers. Animation of algorithms has been used over the past few decades to aid the understanding of programming languages and how they are processed. In this work, we present a generic form of animating CHR programs using source-to-source transformation. The transformation converts CHR programs into their equivalent CHR programs enhanced with animation features, in an automated manner.

Kalema: Digitizing Arabic Content for Accessibility Purposes Using Crowdsourcing

In this paper, we present “Kalema”, a system for digitizing Arabic scanned documents for the visually impaired such that it can be converted to audio format or Braille. This is done through a GWAP which offers a simple, challenging game that helps attract many volunteers for this cause. We show how such a tedious task can be achieved accurately and easily through the use of crowdsourcing.

DiagrammaticCHR: A Diagrammatic Representation of CHR Programs

Recently, a new approach for embedding visualization features into Constraint Handling Rules (CHR) programs has been proposed. It allows CHR programmers to animate and visualize different algorithms implemented in CHR. Such features have become essential with CHR being a general purpose language. In this paper, a new diagrammatic representation for CHR programs is presented. The representation is also able to account for the newly embedded visual features.