Efficiency in nondeterministic control through non-forgetful backtracking

Journal ArticleNondeterministic (ND) control has long been used to express elegant solutions to complex search problems. Programs using ND control can be executed on conventional machines through a systematic examination of trial execution paths. Among the many approaches to the enumeration of these paths is backtracking, a depth-first search of the execution path tree. Despite its implementational advantages, backtracking in its purest form suffers from a "forgetfulness" of retracted execution subpaths. This can lead to exponential run-time on problems such as top-down parsing in which the same subproblem can reoccur in slightly different global contexts. This paper presents an alternative form of ND control implementation incorporating "non-forgetfulness" into backtracking. Reoccurrences of previously searched subgoals are detected and their net computational effects recreated on demand. Since each distinct goal is pursued at most once, search problems such as general top-down parsing run in polynomial time. Moreover, in contrast to an exhaustive, bottom-up approach, goals are only pursued if appropriate in some global context. A strategy for non-forgetful backtracking is outlined in terms of coroutines and ordinary backtracking. The description of an alternative implementation of this strategy using simple coroutines is referenced. Top-down parsing is used to illustrate the application of this technique in both linguistic appearance and execution effect. Finally, some directions for further research into generalizations of these results are suggested

A Monitoring Language for Run Time and Post-Mortem Behavior Analysis and Visualization

UFO is a new implementation of FORMAN, a declarative monitoring language, in which rules are compiled into execution monitors that run on a virtual machine supported by the Alamo monitor architecture.Comment: In M. Ronsse, K. De Bosschere (eds), proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003), September 2003, Ghent. cs.SE/030902

Memoization in Constraint Logic Programming

This paper shows how to apply memoization (caching of subgoals and associated answer substitutions) in a constraint logic programming setting. The research is is motivated by the desire to apply constraint logic programming (CLP) to problems in natural language processing that involve (constraint) interleaving or coroutining, such as GB and HPSG parsing.Comment: 11 page

Isolation and Dependency Resolution of Presentation, Processing and Persistence

For business application development it is important to isolate programming efforts of the concerns: Presentation, Processing and Persistence. Development of each of these concerns has an independent thinking process and requires somewhat different programming languages and development tools. In order to isolate the concerns, we provide passages between the concerns and control the flow of execution by following essentially three rules: 1. Presentation and Processing are coroutines, 2. Processing is finished before Presentation can begin to show output, and 3. Persistence is a subsystem of Processing. We explain how these rules come to existence, and what the implications are in the thesis. By following the rules, a Turing complete Presentation capable of pulling web resource from the server interactively cannot lead a programmer to write code tangling Presentation and Processing. We analyze our design and develop systems in Web 1.0 and Web 2.0 settings. For the latter setting, the system has multiple business component/service dependencies where some of the components run in the browser and some in the server. We show that such distributed component dependency can be resolved while keeping the isolation in place

TgFuseFs: How High School Students Can Write a Filesystem Prototype

Italian high school students who are majoring in Computer Science usually study subjects like programming, databases, networks, system engineering, electronics and operating systems. While most of these subjects let the students practice with projects, operating systems usually is taught in a more theoretical way because practical projects either are too simple to be didactically useful or require too many prerequisites. Hence, components like filesystems are only studied in theory from an high level point of view. We think that building a filesystem prototype could be considered active learning and could improve the operating systems learning experience. For this reason in this work we will show how fifth year students with very few prerequisites can build their first working prototype of a remote filesystem in userspace using Python, FUSE and Telegram. Since the activity is designed for high school students, the prototype won’t be perfect but we will present some of the issues that students should be aware of and more advanced students should address