M.Tech. / E-learning is the industry-accepted term for electronic learning. It is the blending of learning and computer technology with facilitator support, to provide education over the Internet. It is fast becoming an accepted means for the acquisition of knowledge in industry and at institutions of higher learning The research undertaken here elaborates, elucidates, and provides a framework for the implementation of e-learning for teaching computer programming. An experimental elearning course was designed, created and then implemented. Forty-eight learners doing the National Diploma Information technology participated in the e-learning exercise. Questionnaires and the analysis of the participant's assessments formed the empirical base of this work. The opinions expressed by the participants in this study testify to a positive experience and a desire to receive more learning in this manner. It emerged from data analysis in the study that less competent learners still prefer classroom led classes where they have direct interaction with the facilitator. The more independent and competent learner enjoyed this type of learning as it gave them more freedom to work independently and to self-pace their studies. This study reveals the complexity of the concept of teaching programming in an elearning environment and certain guidelines need to be followed to ensure the suitability and effectiveness of the implementation of an e-learning course in programming. Learners need to possess certain competencies in computer usage and should demonstrate their ability to .learn independently.

Typescript (photocopy).

Reading and understanding algorithms is not an easy task and often neglected by educators in an introductory programming course. One proposed solution to this problem is the incorporation of a technological support tool to aid program comprehension in introductory programming. Many researchers advocate the identification of beacons and the use of chunking as support for code comprehension. Beacon recognition and chunking can also be used as support in the teaching model of introductory programming. Educators use a variety of different support tools to facilitate program comprehension in introductory programming. Review of a variety of support tools fails to deliver an existing tool to support a teaching model that incorporates chunking and the identification of beacons. The experimental support tool in this dissertation (BeReT) is primarily designed to encourage a student to correctly identify beacons within provided program extracts. BeReT can also be used to allow students to group together related statements and to learn about plans implemented in any semantically and syntactically correct algorithm uploaded by an instructor. While these requirements are evident in the design and implementation of BeReT, data is required to measure the effect BeReT has on the indepth comprehension of introductory programming algorithms. A between-groups experiment is described which compares the program comprehension of students that used BeReT to study various introductory algorithms, with students that relied solely on traditional lecturing materials. The use of an eye tracker was incorporated into the empirical study to visualise the results of controlled experiments. The results indicate that a technological support tool like BeReT can have a significantly positive effect on student comprehension of algorithms traditionally taught in introductory programming. This research provides educators with an alternative way for the incorporation of in-depth code comprehension skills in introductory programming.

Adhering to the principles of logic programming results in greater expressiveness than is obtained by using the many non-logical features which have been grafted onto current logic programming languages such as Prolog. This report describes an alternative approach to high performance logic programming in which the language and its implementation were designed together. Prolog's non-logical features are discarded and new logical ones are added. Extended pure Prolog (xpProlog) is a superset of conventional Prolog; it is sufficient in itself, without any need for "impure" non-logical predicates. This gives both greater expressiveness and better performance than conventional Prologs. XpProlog programs have the following advantages over conventional Prolog programs: • They are often easier to understand because their meaning does not rely on the underlying computational mechanism. • Coroutining, automatic delaying and sound negation are available. • As technology improves, better implementations and optimization techniques can be used without affecting existing programs. This report covers: • The proper use of logic programming. • How Prolog must be changed to become a good logic programming language (xpProlog). • Sound negation and coroutining. • An efficient abstract machine (xpPAM) which can be efficiently emulated on conventional machines, translated to conventional machine code, or implemented in special purpose hardware. • How to compile extended Prolog and functional (applicative) languages to the abstract machine or to conventional machine code. • Discussion of alternative Prolog abstract machine designs. The xpProlog Abstract Machine's design allows: • Performance similar to the Warren Abstract Machine (WAM) for sequential programs. • Tail recursion optimization (TRO). • Parallelism and coroutining with full backtracking. • Dynamic optimization of clause order. • Efficient if-then-else ("shallow" backtracking). • Simple, regular instruction set for easily optimized compilation. • Efficient memory utilization. • Integrated object-oriented virtual memory. • Predicates as first-class objects. • Simple extension to functional programming. C.R. categories: 1.2.5: Prolog; D.1.3: concurrent programming; D.3.2: very high level languages; D.3.3: language constructs: coroutines, backtracking; D.3.4: 1 interpreters.; 1.2.3: logic programming. / Science, Faculty of / Computer Science, Department of / Graduate

I start with a brief introduction to the graphics processing unit (GPU) as well as general-purpose computation on modern graphics hardware (GPGPU). Next, I explore the motivations for GPGPU programming, and the capabilities of modern GPUs (including advantages and disadvantages). Also, I give the background required for further exploring GPU programming, including the terminology used and the resources available. Finally, I include a comprehensive survey of previous and current GPGPU work, and end with a look at the future of GPU programming.

This thesis describes the implementation of a general purpose personal information storage and retrieval system. Chapter one contains an introduction to information storage and retrieval. Chapter two contains a description of the features a useful personal information retrieval system should contain. This description forms the basis for the implementation of the personal information storage and retrieval system described in chapter three. The system is implemented in UCSD Pascal on an Apple II microcomputer.

A common challenge in the development of web applications today lies in the handling of unforeseen navigation steps initiated by the user through the browser’s Back, Forward and Reload buttons. These operations break the synchrony of dialog states on the server and the client, provoking non-intuitive and possibly destructive application behaviour if not properly handled. We therefore present an approach to handling Back and Forward navigation that realizes undo/redo semantics and illustrate its implementation using the example of a web-based conference management system. The presented approach is subsequently discussed with regard to its general applicability and alternative handling semantics.

The domain requirements of software projects often seem so specialized to developers that their original design does not incorporate any commercial-off-the-shelf (COTS) components. However, if major implementation problems are encountered at a later stage in the project, the integration of a COTS component that promises to solve those problems may become a desirable alternative to struggling on with the original implementation. While a number of methods and criteria have already been proposed for requirements engineering, risk assessment and candidate selection of COTS components, they were developed for application in the initial phases of a project and thus do not take into account the much tighter time and design constraints imposedin a later project stage. To spark discussion on necessary adaptations of the established methods, this position paper uses the example of a concrete project to illustrate the characteristics of “switch or struggle” situations and proposes an initial set of risk factors to be considered at that time.

Over the last few years, the importance of computer science education for children has been promoted more and more vigorously. In addition, the demand for technology occupations has increased rapidly, and there are many job opportunities in computer science. However, there are not many women working in this field. One of the reasons is young women’s lack of interest in computer science. This study investigates how to attract young women to computer programming and support computational thinking through design and develop learning activities. This study’s approach includes several related researches, theories, and methodologies. Interviews, workshops, and observations were used to determine design requirements. The results demonstrate that tangible and meaningful artifacts are effective educational tools for computer programming. Based on the results, this research developed a prototype, “TomatoBox,” a do-it-yourself kit that creates toys while providing an enjoyableactivity to learn programming.

Tools that perform semi-automated refactoring are currently under-utilized by programmers. If more programmers adopted refactoring tools, software projects could make enormous productivity gains. However, as more advanced refactoring tools are designed, a great chasm widens between how the tools must be used and how programmers want to use them. This dissertation begins to bridge this chasm by exposing usability guidelines to direct the design of the next generation of programmer-friendly refactoring tools, so that refactoring tools fit the way programmers behave, not vice-versa.