Phonological Translation in Bilingual and Monolingual Children

Bilingual children face a variety of challenges that their monolingual peers do not. For instance, switching between languages requires the phonological translation of proper names, a skill that requires mapping the phonemic units of one language onto the phonemic units of the other. Proficiency of phonological awareness has been linked to reading success, but little information is available about phonological awareness across multiple phonologies. Furthermore, the relationship between this kind of phonological awareness and reading has never been addressed. The current study investigated phonological translation using a task designed to measure children's ability to map one phonological system onto another. A total of 425 kindergarten and second grade monolingual and bilingual students were evaluated. The results suggest that monolinguals generally performed poorly. Bilinguals translated real names more accurately than fictitious names, in both directions. Correlations between phonological translation and measures of reading ability were moderate, but reliable. Phonological translation is proposed as a tool with which to evaluate phonological awareness through the perspective of children who live with two languages and two attendant phonemic systems.

Text as Resistance in Holocaust Literature: Struggles for Personhood in Wiesel, Levi, and Delbo

This thesis is an examination of the memoirs of three core Holocaust writers, Elie Wiesel (Night and Day), Primo Levi (If This is A Man), and Charlotte Delbo (Auschwitz and After), exploring the ways in which each of the three authors uses his or her memoir to simultaneously document and resist the dehumanizing influence of the concentration camp experience.

France, Italy, and Spain: Culturally Similar Nations, Yet Drastically Different In Their Roles as European Union Nations

Since France, Italy and Spain are neighboring Western European countries, whose languages and cultures have descended from Latin, it is inevitable that these countries share similarities on many levels. France, Italy and Spain share similar lifestyles, religious values and cultural heritages. Throughout history France, Italy and Spain have experienced many of the same historical events because of their geographical proximity. Now that all three countries are members of the European Union they have become further united by occupying a common area without border controls, and sharing a common market, laws, and currency. While France, Italy and Spain share many commonalities, their opinions and relationships within the European Union are diverse. Although each nation struggles to balance its national identity with its European identity and to maintain its sovereignty while at the same time giving some of it up to the EU, each nation has its own ideas about how much its identity should change and how much sovereignty it should give up to the EU government. Each nation also has unique opinions about what it means to part of the European Union and what the requirements for becoming a member nation should be. Each nation has different goals it hopes to accomplish for its own country and for the European Union. The differing ideas amongst France, Italy and Spain are a result of the variance that exists amongst their political and economic relationships and institutions, which have been molded by the historical experiences of each nation. The focus of this paper will be examining why France, Spain and Italy share many cultural similarities, yet differ so greatly in their roles as members of the European Union. After a brief background on the European Union, I will discuss the cultural similarities France, Italy and Spain share. I will then mention several economic and political differences between the three countries and use supporting evidence to explain why and in what context these differences have arisen

Microbe Hunters Revisited – Paul de Kruif and the Beginning of Popular Science Writing

Paul de Kruif is credited with being one of the first popular science writers for the general public. He received his Ph.D. from the University of Michigan in 1916 and worked at the Rockefeller Institute under Simon Flexner. After being fired in 1922 for publishing a scathing article on medical research, de Kruif caught the attention of Sinclair Lewis, who used his scientific background to write his Pulitzer Prize winning novel, Arrowsmith. In 1926, de Kruif published Microbe Hunters which recounted the exploits and discoveries of 14 renowned microbiologists from von Leeuwenhoek to Pasteur, Ross, Paul Ehrlich and Walter Reed. Microbe Hunters became a best seller, was translated into 18 languages, and formed the basis of two Hollywood movies, "Yellow Jack" and "The Magic Bullet." Generations of young readers were captivated by the vivid protrayal of these men and their discoveries.

Independence in CLP Languages

Studying independence of goals has proven very useful in the context of logic programming. In particular, it has provided a formal basis for powerful automatic parallelization tools, since independence ensures that two goals may be evaluated in parallel while preserving correctness and eciency. We extend the concept of independence to constraint logic programs (CLP) and prove that it also ensures the correctness and eciency of the parallel evaluation of independent goals. Independence for CLP languages is more complex than for logic programming as search space preservation is necessary but no longer sucient for ensuring correctness and eciency. Two additional issues arise. The rst is that the cost of constraint solving may depend upon the order constraints are encountered. The second is the need to handle dynamic scheduling. We clarify these issues by proposing various types of search independence and constraint solver independence, and show how they can be combined to allow dierent optimizations, from parallelism to intelligent backtracking. Sucient conditions for independence which can be evaluated \a priori" at run-time are also proposed. Our study also yields new insights into independence in logic programming languages. In particular, we show that search space preservation is not only a sucient but also a necessary condition for ensuring correctness and eciency of parallel execution.

Program debugging and validation using semantic approximations and partial specifications

The technique of Abstract Interpretation [11] has allowed the development of sophisticated program analyses which are provably correct and practical. The semantic approximations produced by such analyses have been traditionally applied to optimization during program compilation. However, recently, novel and promising applications of semantic approximations have been proposed in the more general context of program validation and debugging [3,9,7].

A static heap analysis for shape and connectivity: Unified memory analysis: The base framework

Modeling the evolution of the state of program memory during program execution is critical to many parallehzation techniques. Current memory analysis techniques either provide very accurate information but run prohibitively slowly or produce very conservative results. An approach based on abstract interpretation is presented for analyzing programs at compile time, which can accurately determine many important program properties such as aliasing, logical data structures and shape. These properties are known to be critical for transforming a single threaded program into a versión that can be run on múltiple execution units in parallel. The analysis is shown to be of polynomial complexity in the size of the memory heap. Experimental results for benchmarks in the Jolden suite are given. These results show that in practice the analysis method is efflcient and is capable of accurately determining shape information in programs that créate and manipúlate complex data structures.

A generic persistence model for CLP systems (and two useful implementations)

This paper describes a model of persistence in (C)LP languages and two different and practically very useful ways to implement this model in current systems. The fundamental idea is that persistence is a characteristic of certain dynamic predicates (Le., those which encapsulate state). The main effect of declaring a predicate persistent is that the dynamic changes made to such predicates persist from one execution to the next one. After proposing a syntax for declaring persistent predicates, a simple, file-based implementation of the concept is presented and some examples shown. An additional implementation is presented which stores persistent predicates in an external datábase. The abstraction of the concept of persistence from its implementation allows developing applications which can store their persistent predicates alternatively in files or databases with only a few simple changes to a declaration stating the location and modality used for persistent storage. The paper presents the model, the implementation approach in both the cases of using files and relational databases, a number of optimizations of the process (using information obtained from static global analysis and goal clustering), and performance results from an implementation of these ideas.

Using attributed variables in the implementation of concurrent and parallel logic programming systems

Incorporating the possibility of attaching attributes to variables in a logic programming system has been shown to allow the addition of general constraint solving capabilities to it. This approach is very attractive in that by adding a few primitives any logic programming system can be turned into a generic constraint logic programming system in which constraint solving can be user deñned, and at source level - an extreme example of the "glass box" approach. In this paper we propose a different and novel use for the concept of attributed variables: developing a generic parallel/concurrent (constraint) logic programming system, using the same "glass box" flavor. We argüe that a system which implements attributed variables and a few additional primitives can be easily customized at source level to implement many of the languages and execution models of parallelism and concurrency currently proposed, in both shared memory and distributed systems. We illustrate this through examples and report on an implementation of our ideas.

On the role of semantic approximations in validation and diagnosis of constraint logic programs

Abstract is not available.

A generic preprocessor for program validation and debugging

We present a generic preprocessor for combined static/dynamic validation and debugging of constraint logic programs. Passing programs through the preprocessor prior to execution allows detecting many bugs automatically. This is achieved by performing a repertoire of tests which range from simple syntactic checks to much more advanced checks based on static analysis of the program. Together with the program, the user may provide a series of assertions which trigger further automatic checking of the program. Such assertions are written using the assertion language presented in Chapter 2, which allows expressing a wide variety of properties. These properties extend beyond the predefined set which may be understandable by the available static analyzers and include properties defined by means of user programs. In addition to user-provided assertions, in each particular CLP system assertions may be available for predefined system predicates. Checking of both user-provided assertions and assertions for system predicates is attempted first at compile-time by comparing them with the results of static analysis. This may allow statically proving that the assertions hold (Le., they are validated) or that they are violated (and thus bugs detected). User-provided assertions (or parts of assertions) which cannot be statically proved ñor disproved are optionally translated into run-time tests. The implementation of the preprocessor is generic in that it can be easily customized to different CLP systems and dialects and in that it is designed to allow the integration of additional analyses in a simple way. We also report on two tools which are instances of the generic preprocessor: CiaoPP (for the Ciao Prolog system) and CHIPRE (for the CHIP CLP(FL>) system). The currently existing analyses include types, modes, non-failure, determinacy, and computational cost, and can treat modules separately, performing incremental analysis.

On the uses of attributed variables in parallel and concurrent logic programming systems

Incorporating the possibility of attaching attributes to variables in a logic programming system has been shown to allow the addition of general constraint solving capabilities to it. This approach is very attractive in that by adding a few primitives any logic programming system can be turned into a generic constraint logic programming system in which constraint solving can be user defined, and at source level - an extreme example of the "glass box" approach. In this paper we propose a different and novel use for the concept of attributed variables: developing a generic parallel/concurrent (constraint) logic programming system, using the same "glass box" flavor. We argüe that a system which implements attributed variables and a few additional primitives can be easily customized at source level to implement many of the languages and execution models of parallelism and concurrency currently proposed, in both shared memory and distributed systems. We illustrate this through examples.

An abstract machine based execution model for computer architecture design and efficient implementation of logic programs in parallel.

The term "Logic Programming" refers to a variety of computer languages and execution models which are based on the traditional concept of Symbolic Logic. The expressive power of these languages offers promise to be of great assistance in facing the programming challenges of present and future symbolic processing applications in Artificial Intelligence, Knowledge-based systems, and many other areas of computing. The sequential execution speed of logic programs has been greatly improved since the advent of the first interpreters. However, higher inference speeds are still required in order to meet the demands of applications such as those contemplated for next generation computer systems. The execution of logic programs in parallel is currently considered a promising strategy for attaining such inference speeds. Logic Programming in turn appears as a suitable programming paradigm for parallel architectures because of the many opportunities for parallel execution present in the implementation of logic programs. This dissertation presents an efficient parallel execution model for logic programs. The model is described from the source language level down to an "Abstract Machine" level suitable for direct implementation on existing parallel systems or for the design of special purpose parallel architectures. Few assumptions are made at the source language level and therefore the techniques developed and the general Abstract Machine design are applicable to a variety of logic (and also functional) languages. These techniques offer efficient solutions to several areas of parallel Logic Programming implementation previously considered problematic or a source of considerable overhead, such as the detection and handling of variable binding conflicts in AND-Parallelism, the specification of control and management of the execution tree, the treatment of distributed backtracking, and goal scheduling and memory management issues, etc. A parallel Abstract Machine design is offered, specifying data areas, operation, and a suitable instruction set. This design is based on extending to a parallel environment the techniques introduced by the Warren Abstract Machine, which have already made very fast and space efficient sequential systems a reality. Therefore, the model herein presented is capable of retaining sequential execution speed similar to that of high performance sequential systems, while extracting additional gains in speed by efficiently implementing parallel execution. These claims are supported by simulations of the Abstract Machine on sample programs.

Automatic compile-time parallelization of CLP programs by analysis and transformation to a concurrent constraint language.

The concept of independence has been recently generalized to the constraint logic programming (CLP) paradigm. Also, several abstract domains specifically designed for CLP languages, and whose information can be used to detect the generalized independence conditions, have been recently defined. As a result we are now in a position where automatic parallelization of CLP programs is feasible. In this paper we study the task of automatically parallelizing CLP programs based on such analyses, by transforming them to explicitly concurrent programs in our parallel CC platform (CIAO) as well as to AKL. We describe the analysis and transformation process, and study its efficiency, accuracy, and effectiveness in program parallelization. The information gathered by the analyzers is evaluated not only in terms of its accuracy, i.e. its ability to determine the actual dependencies among the program variables, but also of its effectiveness, measured in terms of code reduction in the resulting parallelized programs. Given that only a few abstract domains have been already defined for CLP, and that none of them were specifically designed for dependency detection, the aim of the evaluation is not only to asses the effectiveness of the available domains, but also to study what additional information it would be desirable to infer, and what domains would be appropriate for further improving the parallelization process.

Public policies and multilingualism in HCI

Language is an essential aspect of human communication and interaction, not only between humans but also between humans and interactive systems. Indeed, the use of the language is a keystone for the design of interactive systems.Inappropriate use of language might limit the access of users to information and induce users to make mistakes or to lose control of interactive systems. Despite the existence of public policies, the diversity of languages poses serious problems when considering full-fledged/seamless support for all existing languages. And yet standardization processes have successfully defined mechanisms for ensuring cross-platform compatibility between languages, at least at the level of format and the set of characters that can be used.