Pitfalls in PROLOG programming

This paper describes a Turbo Pascal program that explicitly emulates a Turbo Prolog program. The intended purpose of the Pascal program is to relate important implementation details of Prolog to concepts in a conventional programming language.

Recursive function theory studies functions that can be evaluated by an algorithm based on some computing model such as a Turing machine or computer program. These functions are called partial recursive (p.r.) and are defined on subsets of N, where N = {0, 1,... }, with values in N. (A good introduction to the theory may be found in [2].) This paper explains the Parameter Theorem, illustrates some unusual computer programs, and explains their connection to recursive function theory. Basing our computing model on a modern high level language, we can construct programs whose existence is known through more formal means. Our functions will operate on strings rather than numbers, however. There is no loss in generality since strings can be viewed as members of N, and vice-versa. From a practical aspect, this approach is somewhat more desirable since conventional programming languages often allow making use of long strings, but place more restrictive limits on the size of integers. We first pose a problem: Does there exist a program (written in some conventional programming language) which halts if and only if its input is identical to the program's text (i.e., source code)? For the remainder of this note X is the set of ASCII characters 'a,' 'b, +,' space, line feed, and so forth, needed to write programs in most programming languages. We denote by X * the set of all strings (finite sequences) over X. Let P1 be the set of all one variable partial recursive functions on X *. A function I belongs to P1 if and only if there is a subset of S of X* and some algorithm which computes 't by associating with each element of S a well-defined element of X *. Similarly, 't belongs to P2 if and only if there is a set S c X * X X *, and an algorithm for 't which associates with each element of S a well-defined element of X *. A partial recursive function I in P1 (or in P2) is recursive if the algorithm is defined on all of X * (or X * X X *). This is equivalent to saying that the algorithm which evaluates I always halts. Our computing model will be based on Adat; its high-level string-handling properties simplify later examples. For readability, however, we will express algorithms in a more familiar Pascal-like style. Readers familiar with either programming language should find forthcoming algorithms sufficiently clear. A formal presentation in Ada is given in the Appendix. A string of ASCII characters, such as in FIGURE 1, represents a function in our language which takes strings to strings. Of course, strings of ASCII characters such as The quick brown fox and %*!! represent nothing at all in our programming language. Let A1 be the set of all strings in X * representing functions in our language of one input STRING which outputs a STRING. Similarly let A2 be the set of all strings in

Are Scripting Languages Any Good? A Validation of Perl, Python, Rexx, and Tcl against C, C++, and Java

Discrete Event Simulation (DES) is a widely used technique in which the state of the simulator is updated by events happening at discrete points in time (hence the name). DES is used to model and analyze many kinds of systems, including computer architectures, communication networks, street traffic, and others. Parallel and Distributed Simulation (PADS) aims at improving the efficiency of DES by partitioning the simulation model across multiple processing elements, in order to enabling larger and/or more detailed studies to be carried out. The interest on PADS is increasing since the widespread availability of multicore processors and affordable high performance computing clusters. However, designing parallel simulation models requires considerable expertise, the result being that PADS techniques are not as widespread as they could be. In this paper we describe ErlangTW, a parallel simulation middleware based on the Time Warp synchronization protocol. ErlangTW is entirely written in Erlang, a concurrent, functional programming language specifically targeted at building distributed systems. We argue that writing parallel simulation models in Erlang is considerably easier than using conventional programming languages. Moreover, ErlangTW allows simulation models to be executed either on single-core, multicore and distributed computing architectures. We describe the design and prototype implementation of ErlangTW, and report some preliminary performance results on multicore and distributed architectures using the well known PHOLD benchmark.

Constraint Logic Programming (CLP) languages extend logic programming by allowing the use of constraints from different domains such as real numbers or Boolean functions. They have proved to be ideal for expressing problems that require interactive mathematical modeling and complex combinatorial optimization problems. However, CLP languages have mainly been considered as research systems, useful for rapid prototyping, by not really competitive with more conventional programming languages where efficiency is a more important consideration. One promising approach to improving the performance of CLP systems is the use of powerful program optimizations to reduce the cost of constraint solving. We extend work in this area by describing a new optimizing compiler for the CLP language CLP(ℛ). The compiler implements six powerful optimizations: reordering of constraints, removal of redundant variables, and specialization of constraints which cannot fail. Each program optimization is designed to remove the overhead of constraint solving when possible and keep the number of constraints in the store as small as possible. We systematically evaluate the effectiveness of each optimization in isolation and in combination. Our empirical evaluation of the compiler verifies that optimizing compilation can be made efficient enough to allow compilation of real-world programs and that it is worth performing such compilation because it gives significant time and space performance improvements.

End-user scripting languages are relatively easy to learn, but have limited expressive power. Tile-based scripting systems are particularly accessible to beginners, but usually are very limited in scope and usually lack extensibility, and for some tasks the tile idiom becomes cumbersome. Conventional programming languages used by computer professionals are far more powerful, but at the cost of additional complexity and limited environmental support, which place them out of the casual programmer's reach. This paper presents TileScript, an attempt to combine the accessibility of a tile-based programming interface with the leverage of a full textual programming language and with a simple means of extension, making it potentially an appealing tool for the novice programmer without sacrificing any expressiveness. All TileScript programs, whether built originally with tiles or textually, can always be edited both graphically via a drag-and-drop tile interface and textually, and the user can freely switch back and forth between tile and textual representations at any time. Additionally TileScript's simple yet powerful extensibility mechanisms allow the language to be used to tackle problems that would normally be out of the scope of an end-user scripting language.

Recent compilers allow a general-purpose program (written in a conventional programming language) that handles private data to be translated into a secure distributed implementation of the corresponding functionality. The resulting program is then guaranteed to provably protect private data using secure multi-party computation techniques. The goals of such compilers are generality, usability, and efficiency, but the complete set of features of a modern programming language has not been supported to date by the existing compilers. In particular, recent compilers PICCO and the two-party ANSI C compiler strive to translate any C program into its secure multi-party implementation, but they currently lack support for pointers and dynamic memory allocation, which are important components of many C programs. In this work, we mitigate the limitation and add support for pointers to private data and consequently dynamic memory allocation to the PICCO compiler, enabling it to handle a more diverse set of programs over private data. Because doing so opens up a new design space, we investigate the use of pointers to private data (with known as well as private locations stored in them) in programs and report our findings. Aside from dynamic memory allocation, we examine other important topics associated with common pointer use such as reference by pointer/address, casting, and building various data structures in the context of secure multi-party computation. This results in enabling the compiler to automatically translate a user program that uses pointers to private data into its distributed implementation that provably protects private data throughout the computation. We empirically evaluate the constructions and report on the performance of representative programs.

The inductive types of Coq extend the various notions of type definitions provided in conventional programming languages. They can be compared to the recursive type definitions found in most functional programming languages. However, the possibility of mixing recursive types and dependent products makes the inductive types of Coq much more precise and expressive, up to the point where they can also be used to describe pure logic programming, in other words the primitive kernel of Prolog.

The language of universal algebras is used as an alternative approach for programming language specification. BNF (Backus-Naur form) rules are used for specifying the signature of the language algebras instead of the context-free syntax. The algorithm for program parsing is inductively defined by the following universal algebraic construction: any function defined on the generators of a free algebra taking values in the carrier of another similar algebra can be uniquely extended to a homomorphism between the two algebras; any conventional programming language can be specified by a finite set of BNF rules and its algebra of symbols is generated by a finite set of generator classes. Thus, any function defined on the finite set of generators offers an algebraic mechanism for a universal algorithm for source language program parsing. The right-hand side of the BNF rules are the patterns searched by the algorithm in the source text of the program. The essential feature of this algorithm is that it can be used as a driver for code generation and optimization in a translator. >

Parallel programs have traditionally been implemented on distributed systems using conventional programming languages, such as Fortran or C, plus a library with support for communication, such as, for instance, PVM [11]. Also, some effort has been put into developing parallel programming languages [13]. Usually, the different development platforms are compared as to application execution time or parallel efficiency. However, as pointed out in [4], when measuring the performance of a parallel application or programming tool, different metrics may need to be taken into consideration. The ease of construction of an application and the time a programmer spends to implement it may in some cases be more important than the final execution time. Working under this assumption, this work argues that the use of interpreted languages as a basis for parallel programming tools should be further investigated. As support for our argument, we show an example of use of an interpreted language in a classical application in parallel distributed programming, namely, that of detecting program termination. Two different algorithms for termination detection are implemented in Lua, an extension language developed at PUC-Rio [5].

Normative organisations provide a means to coordinate the activities of individual agents in multiagent settings. The coordination is realized at run time by creating obligations and prohibitions (norms) for individual agents. If an agent cannot meet an obligation or violates a prohibition, the organisation imposes a sanction on the agent. In this paper, we consider norm-aware agents that deliberate on their goals, norms and sanctions before deciding which plan to select and execute. A norm-aware agent is able to violate norms (accepting the resulting sanctions) if it is in the agent's overall interests to do so, e.g., if meeting an obligation would result in an important goal of the agent becoming unachievable. Programming norm-aware agents in conventional BDI-based agent programming languages is difficult, as they lack support for deliberating about goals, norms, sanctions and deadlines. We present the norm-aware agent programming language N-2APL. N-2APL is based on 2APL and provides support for beliefs, goals, plans, norms, sanctions and deadlines. We give the syntax and semantics of N-2APL, and show that N-2APL agents are rational in the sense of committing to a set of plans that will achieve the agent's most important goals and obligations by their deadlines while respecting its most important prohibitions.

Two studies were conducted to examine the use of grounded embodied pedagogy, construction of Imaginary Worlds (Study 1), and context of instructional materials (Study 2) for developing learners' Computational Thinking (CT) Skills and Concept knowledge during the construction of digital artifacts using Scratch, a block-based programming language. Utilizing a conceptual framework for grounded embodied pedagogy called Instructional Embodiment, learners physically enacted (Direct Embodiment) and mentally simulated (Imagined Embodiment) the actions and events as presented within pre-defined Scripts. Instructional Embodiment utilizes action, perception, and environment to create a dynamic, interactive teaching & learning scenario that builds upon previous research in embodied teaching and learning. The two studies described herein examined the effects of Instructional Embodiment, Imaginary World Construction, and Context on the development of specific Computational Thinking Concepts and Skills. In particular, certain CT Concepts, such as Conditionals, Variables, Thread Synchronization, Collision Detection, & Events, and CT Skills, such as abstraction and pattern recognition, were identified and measured within the learners' individual digital artifacts. Presence and/or frequency of these Concepts and Skills were used to determine the extent of Computational Thinking development. In Study 1, fifty-six sixth- and seventh-grade students participated in a fifteen-session curricular program during the academic school day. This study examined the type of instruction and continuity of Imaginary World Construction on the development of certain CT Skills and Concepts used in a visual novel created in Scratch. Main effects were found for learners who physically embodied the pre-defined instructional materials: embodying the pre-defined Scripts led to the learners using significantly more ‘speech’ Blocks in their projects and more Absolute Positioning Blocks for ‘motion’ than those who did not physically embody the same Scripts. Significant main effects were also found for continuity of Imaginary World Construction: learners who were instructed to continue the premise of the first digital artifact (Instructional Artifact) implemented significantly more computational structures in their second digital artifact (Unique Artifact) than those who were instructed to create a Unique Artifact with a premise of their own design. In Study 2, seventy-eight sixth- and seventh-grade students participated in a seventeen-session curricular program during the academic school day. This study examined the type of instruction and context of instructional materials on the development of CT Skills and Concepts during the construction of a video game using Scratch. Similar to Study 1, findings suggest that physically embodying the actions presented within the pre-defined instructional materials leads to greater implementation of many of these same structures during individual artifact construction. The study also showed that as the pre-defined Scripts become more complex (e.g. single-threaded to multi-threaded), the effect of physical embodiment on the development of CT Skills and complex CT Concept structures becomes less pronounced. Findings from this study also suggest that Context has a significant effect on identifying & implementing the CT Skill pattern recognition: learning CT Concepts from an Unfamiliar Context had a significant positive effect on the implementation of both Broadcast/Receive couplings and Conditional Logic & Operator patterns. In sum, the findings suggest that the type of instruction, the continuity of the Imaginary World being constructed, and the context of the instructional materials all play a significant role in the learners' ability to develop certain Computational Thinking Skills and Concept knowledge. The findings also suggest that a physically embodied approach to teaching abstract concepts that is grounded in an unfamiliar context is the most effective way to integrate a grounded embodied approach to pedagogy within a formal instructional setting.

Improvements in distributed computing, and the technologies that enable them, have led to significant advancements in middleware functionality and quality, mainly through networking and protocols. However, the distributed programing style has changed little over the years. Most programs are still written line per line of code in languages such as C, C++, and Java. These conventional programs that can provide grid operations and grid data can be considered as common grid resources and shared by research and education communities worldwide. However, there are no relevant programing methodologies to utilize efficiently these shared service providers as a potentially vast grid repository, except through the manual writing of code. Realization of the potential of grid computing requires significant improvements in grid programing methodologies. The Grid interactive service-oriented (GISO) methodology presented provides a programming environment with development tools that permit true interactive grid programming. The GISO approach permits the different elements of programming to be stored, reused, aggregated, and executed with concurrency and a grid-level control strategy not achievable in the conventional programming languages.

We present the fundamentals of the quantum theoretical approach we have developed in the last decade to model cognitive phenomena that resisted modeling by means of classical logical and probabilistic structures, like Boolean, Kolmogorovian and, more generally, set theoretical structures. We firstly sketch the operational-realistic foundations of conceptual entities, i.e. concepts, conceptual combinations, propositions, decision-making entities, etc. Then, we briefly illustrate the application of the quantum formalism in Hilbert space to represent combinations of natural concepts, discussing its success in modeling a wide range of empirical data on concepts and their conjunction, disjunction and negation. Next, we naturally extend the quantum theoretical approach to model some long-standing `fallacies of human reasoning', namely, the `conjunction fallacy' and the `disjunction effect'. Finally, we put forward an explanatory hypothesis according to which human reasoning is a defined superposition of `emergent reasoning' and `logical reasoning', where the former generally prevails over the latter. The quantum theoretical approach explains human fallacies as the consequence of genuine quantum structures in human reasoning, i.e. `contextuality', `emergence', `entanglement', `interference' and `superposition'. As such, it is alternative to the Kahneman-Tversky research programme, which instead aims to explain human fallacies in terms of `individual heuristics and biases'.

Constraint Handling Rules (CHR) [2,5] is a high-level programming language based on multi-headed, committed-choice, guarded multiset rewrite rules. Originally designed in 1991 by Frühwirth for the particular purpose of adding user-defined constraint solvers to a host-language, CHR has matured over the last decade to a powerful and elegant general-purpose language with a wide spectrum of application domains.Different semantics have been proposed for the language, based on various logics (first-order logic, linear logic, ...). These logics, in combination with rewriting techniques, have been used to study program properties such as soundness and completeness, confluence, termination, ...While that line of work treats CHR as a calculus, this tutorial teaches CHR as a proper programming language.As a programming language, CHR seems simple enough: The programmer specifies a number of rewrite rules, and the CHR engine applies these rules exhaustively to an initial (multi-)set of constraints. Yet, this simplicity hides great power: e.g., the power to quickly prototype new constraint solvers, the power to implement Prolog’s co-routining predicates freeze/2 and when/2 in a single CHR rule each, and the power to subsume Guarded Horn Clauses while still not exploiting CHR’s full potential. Moreover, CHR is the only declarative language known in which every algorithm can be implemented with optimal space and time complexity [4].Unfortunately, few Prolog programmers are aware of the CHR language or that it is available in their Prolog system. These programmers are unable to tap into CHR’s power, so they have to go to great length to accomplish even simple tasks. Or they simply give up. This tutorial shows how to use CHR for solving their problems quickly and elegantly. Simple examples teach interactively how to write and reason about CHR programs, and what problems one can solve effectively with CHR.This tutorial starts with ground CHR, the three types of rules, and the refined semantics [1] which is based on the notion of the active constraint and its occurrences. Other topics covered are triggering of rules, the propagation history, the use of data structures and the host language, declarations and impure features, and the common pitfalls of CHR.This tutorial intends to make the attendants aware of CHR’s strengths as a programming language, and teaches them when and how to apply CHR for small to medium sized problems. The full set of tutorial slides is available at http://www.cs.kuleuven.be/~dtai/projects/CHR/ . About the Speaker. Tom Schrijvers is a post-doctoral researcher at the K.U.Leuven in Belgium, who has defended his Ph.D. thesis on Analyses, Optimizations and Extensions of Constraint Handling Rules in 2005 [3]. His CHR implementation, the K.U.Leuven CHR system, is the most advanced in its kind and is in wide-spread use in many Prolog systems. Tom uses CHR on a daily basis, for implementing his compiler, for supporting his type checking and test generation research, or simply for gaining an edge in the Prolog Programming Contest.KeywordsProgramming LanguageImpure FeatureActive ConstraintLinear LogicConstraint SolverThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.