Haider Ali Ramadhan

Programming by discovery

Abstract The concept of Programming by Discovery refers to the process of designing programming environments and systems which use various visualisation, programming and interaction technologies in an effective way to help users, especially beginner programmers, in writing computer programs, understanding their dynamic behaviour, detecting any misconceptions and bugs associated with them, and seeing the effect of these programs on the underlying machine. A system for programming by discovery encourages a user to become an active learner by allowing him to form his own hypotheses, explore his own questions, and draw his own conclusions. This paper reports on the design and evaluation of a system for programming by discovery which embodies the principles outlined above. To assess the usefulness of the design framework presented in this paper, a pilot empirical evaluation was conducted. The results provided a number of interesting insights into the implication of incorporating visualisation and immediacy features along with graphical notional machine and algorithm-like language into the design of programming systems.

Incorporating Software Visualization in the Design of Intelligent Diagnosis Systems for User Programming

Program diagnosis systems were developed to help users solve programming problems. By providing guidence on errors and misconceptions, these systems can help the users in writing programs and understanding their dynamic behavior. Features of software visualization which aim at providing visual and concrete depictions to the abstractions and operations of programs have also shown to be making programs more understandable. The main theme of this paper is to asses the usefulness of incorporating features of software visualization into the design of program diagnosis systems intended for novices. We report an empirical evaluation to assess the effectiveness of supporting visualization features during problem solving. The system used in the evaluation integrates visualzation and immediacy features and supports a model-tracing based approach to program diagnosis. Unlike other similar systems, our prototype system supports a more flexible style of interaction by increasing the grain size of diagnosis to a complete programming statement. The evaluation reported here seems to suggest that when supported with visualization features, systems for program diagnosis tend to be more effective in helping the users during problem solving.

A Critical Analysis and Evaluation of Web-based Environments for Program Development

This paper provides a classification, review, and critical analysis of current Web-based interactive programming environments and tools that facilitate learning programming languages and concepts. The focal point of the paper is based on (1) categorizing available programming systems and tools into classes according to their pedagogical approaches; (2) reviewing individual systems; and (3) critically analyzing them according to established standards for instructional design. The paper is intended to provide those seeking to use these resources with a comprehensive survey of the available systems, their succinct evaluation, and their effectiveness.

Critical Analysis of the PIE Testability Technique

The work of Voas and colleagues has introduced, refined and applied the propagation, infection and execution (PIE) analysis technique for measuring testability of programs. The purpose of this paper is twofold: (1) to summarize and review the work done by Voas and others, and (2) to lay down a framework for automating the measurement of testability. In doing so, we introduce a prototype system, which uses the mutant schemata approach to calculate the infection estimate. The attempt, reported in this paper, to reproduce the results reported by Voas for one example, have shown that intermediate calculations are quite sensitive to minor variations in the parameters to the process, although the final testability results are in agreement.

Improving the engineering of model tracing based intelligent program diagnosis

The model tracing based approach to intelligent program diagnosis and tutoring emphasises the fact that the students design decisions are traced as the student develops the program. A system based on this model monitors the users actions as he/she moves along the solution path, automatically analyses partial solutions for semantic errors and misconceptions, and offers guidance whenever he/she deviates from the correct solution path. In this way, the system always checks to see if the student is following the design path of an ideal model. Buggy paths are pruned as soon as they are discovered. Through this approach to automatic diagnosis and tutoring, a model tracing system can firstly diagnose very specific errors and misconceptions and provide clear advice and explanations within a proper and immediate context; secondly, explicitly guide the user in the process of organising different programming concepts and statements; and thirdly, simplify the engineering of automatic diagnosis by preventing multiple bugs and errors. However, this approach is very directive and interventionist. The user is highly constrained in the solutions that can be developed, as he/she must conform to the task decomposition and coding sequence enforced by model tracing systems. To bypass these pitfalls associated with the traditional model tracing approach, solutions and guidelines are suggested for improving the engineering of model tracing based diagnosis.

The Efficiency of Critical Slicing in Fault Localization

In software testing, developing effective debugging strategies is important to guarantee the reliability of software under testing. A heuristic technique is to cause failure and therefore expose faults. Based on this approach mutation testing has been found very useful technique in detecting faults. However, it suffers from two problems with successfully testing programs: (1) requires extensive computing resources and (2) puts heavy demand on human resources. Later, empirical observations suggest that critical slicing based on Statement Deletion (Sdl) mutation operator has been found the most effective technique in reducing effort and the required computing resources in locating the program faults. The second problem of mutation testing may be solved by automating the program testing with the help of software tools. Our study focuses on determining the effectiveness of the critical slicing technique with the help of the Mothra Mutation Testing System in detecting program faults. This paper presents the results showing the performance of Mothra Mutation Testing System through conducting critical slicing testing on a selected suite of programs.

Automatic Detection of Performance Bottlenecks Using a Case-Based Reasoning Approach

Al though the p rocess of de tec t ing and resolv ing p e r f o r m a n c e bo t t l enecks o f c o m p u t e r sys tems is t i m e c o n s u m i n g and c o m p l e x , it has recent ly b e c o m e more impor tant and popu la r issue because of the increase in the complex i ty and the divers i ty o f these sys tems. Tradi t ional ly , this p roces s has been implemented us ing ru le -based sys tems. We, however , noted that case -based reason ing is more e f f ic ien t and o f great benef i t in this area . T h i s is main ly because non-exper t users o f p e r f o r m a n c e m o d e l i n g or mon i to r i ng so f tware , both in p repar ing inputs and in terpre t ing outputs , tend to use old cases by assoc ia t ing c o m p u t e r sys tems that reveal s imilar p e r f o r m a n c e charac ter is t ics . It is a lso because ru le -based sys tems are less modu la r than case -based sys tems in that a d d i n g (or r e m o v i n g ) a new case in a ca se -based sys tem d o e s not a f fec t any exis t ing case. In this work , we present an app l ica t ion o f our integrated app roach to the d iagnos i s of bo t t lenecks in c o m p u t e r sys t ems in o rde r to p rov ide the necessary r emed ie s to ach ieve accep t ab l e p e r f o r m a n c e . T h e under ly ing t echn ique uses the p e r f o r m a n c e moni to r va lues to f ind the mos t poss ib le a s s ignment to the work load and system pa rame te r s . It is based on case -based r eason ing ut i l izing fuzzy set concep t s to conver t the quant i ta t ive a t t r ibutes into qual i ta t ive t e rms for index ing and ret r ieval . T h e app roach a lso shows that fuzzy indexing and retr ieval a re use fu l in the c o m p u t e r p e r f o r m a n c e doma in . Reprint requests to: Khalil Shihab. Dept. of Computer Science Sultan Qaboos University, PO Box 36 Muscat 123. Oman: e-mail: kshihab@squ.edu.om: *haider@squ.edu.om

A performance evaluation of a new bitmap-based XML processing approach over RDBMS

This paper presents a comprehensive performance analysis of PACD; a novel bitmap-based XML processing approach introduced earlier to resolve several performance issues identified in existing XML database technology. The study evaluated three performance aspects of XML database techniques including query processing, XML updates and scalability. Each of these aspects has been tested using various measures and compared with some representative alternative approaches. Despite its narrow domain for the order-access queries and its high cost in terms of the number IO-read operations, PACD almost performed well in terms of query processing, resource consumption during XML updates and has shown acceptable scalability over a variety of XML database categories.

Automatic discovery of association paths in relational databases using software visualization

We introduce a visual framework for facilitating tasks associated with database maintenance and re-use. The prototype system embodying the framework is presented. The system utilizes various techniques and features of software visualization. The system supports visual displays of the database structure along with various implicit relationships found in it such as associations and path views. Information visualized is automatically extracted from the database schema. To assess the usefulness of the proposed framework in helping the programmers to quickly recognize path views among relations, an empirical evaluation was conducted. Results collected from the evaluation seem to support our hypothesis that the time required to manually recognize path views from the database schema is considerable and tends to increase as the depth between the relations increases. The evaluation also showed that by using our visual framework such time is negligible and tends to be static.

ACTIVE vs. PASSIVE APPROACHES TO INTELLIGENT PROGRAM DIAGNOSIS

Much of research in intelligent programming systems for users has been polarized towards two opposite domains: active and passive approaches to diagnosis. The advocates of the active approach claim that much of the effectiveness of intelligent program systems is contributed to having strong control over the behavior of the users and providing immediate feedback on errors and misconceptions. Opponents of this approach, on the other hand, have argued that active approach through its interventionist style does not provide users the flexibility needed to observe their own behavior and discover their own errors, hence the users are not given an opportunity to selfdebug their solutions. This paper covers the engineering of intelligent program diagnosis systems and reports an empirical evaluation which attempts to get some insights into the superiority of active approach over passive approach or vice versa. The evaluation is conducted using our prototype system DISCOVER. The system provides a visualization-based environment which supports both active and passive modes of intelligent program diagnosis.