Post-colonial (American?) English Presence on the North-Western Pacific Island of Kosrae: A cross-linguistic analysis of the overlaps and divergences of Kosraean English compared to standard American English

Kosrae is the most remote island of the Federated States of Micronesia (FSM), with a population of less than 7,000 inhabitants, located in the Pacific Ocean between Hawaii and Guam. FSM is an independent sovereign nation consisting of four states in total: Pohnpei, Chuuk, Yap, and Kosrae. Having passed through the hands of Spain, Germany and Japan, the United States gained administrative control of FSM after WWII, as commissioned by the UN. The FSM became an independent nation in 1986 while still retaining affiliation with the US under a ‘Compact of Free Association’. Now both Kosraean and English are considered to be the two official languages and the variety of Kosraean English which has arisen proves for an interesting comparative study. In order to obtain the relevant data, I spent three months on the island of Kosrae, interviewing 90 local speakers, ranging in age (16-70), occupation, sex and time spent off island. The 45 minute long interviews were informal but supported by participant information to capture relevant data and conversations were guided in a way that aimed to reveal language and cultural attitudes. With reference to these samples, I examine the effects of American English on the language use in Kosrae. This paper aims to present a broad analysis of phonological, morphosyntactic and pragmatic features, such as pro-dropping, discourse markers and other practices in order to demonstrate the similarities and differences between the two varieties, which are coming to shape the variety developing on Kosrae. Having transcribed conversations using the tool Elan, I will put particular focus on [h] deletion and insertion, a rare occurrence found in a variety of post-colonial American English which I believe is of particular interest. I assess the presence of English in Kosrae with reference to sociological influences, past and present. First, I discuss the extralinguistic factors which have shaped the English that is currently used on Kosrae, including migration between US and FSM, and English as a language of administration, social media usage and visual media presence. Secondly, I assess the use of English in this community in light of Schneider’s (2007) ‘Dynamic Model’, with reference to America’s contribution as an ‘exploitation colony’ as defined by Mufwene (2001). Finally, an overview of the salient linguistic characteristics of Kosraean English, based on the data collected will be presented and compared to features associated with standard American English in view of examining overlap and divergence. The overall objective is to present a cross-linguistic description of a hitherto unexamined English emerging in a postcolonial environment with a juxtaposed contact variety. Mufwene, Salikoko S. 2001. The ecology of language evolution. Cambridge: Cambridge University Press. Schneider, E. (2007). Postcolonial Englishes. Cambridge: Cambridge University Press. Segal, H.G. (1989) Kosrae, The Sleeping Lady Awakens. Kosrae: Kosrae Tourist Division, Dept. Of Conservation and Development. Keywords: American English, Global English, Pacific English, Morphosyntactic, Phonological, Variation, Discourse

Trends in Phonetics and Phonology

This volume was inspired by the 9th edition of the Phonetik and Phonologie conference, held in Zürich in October 2013. It includes state of the art research on phonetics and phonology in various languages and from interdisciplinary contributors. The volume is structured into the following eight sections: segmentals, suprasegmentals, articulation in spoken and sign language, perception, phonology, crowdsourcing phonetic data, second language speech, and arts (with inevitable overlap between these areas).

Polymorphism in the Spotlight: Studying its Prevalence in Java and Smalltalk

Subtype polymorphism is a cornerstone of object-oriented programming. By hiding variability in behavior behind a uniform interface, polymorphism decouples clients from providers and thus enables genericity, modularity and extensi- bility. At the same time, however, it scatters the implementation of the behavior over multiple classes thus potentially hampering program comprehension. The extent to which polymorphism is used in real programs and the impact of polymorphism on program comprehension are not very well understood. We report on a preliminary study of the prevalence of polymorphism in several hundred open source software systems written in Smalltalk, one of the oldest object-oriented programming languages, and in Java, one of the most widespread ones. Although a large portion of the call sites in these systems are polymorphic, a majority have a small number of potential candidates. Smalltalk uses polymorphism to a much greater extent than Java. We discuss how these findings can be used as input for more detailed studies in program comprehension and for better developer support in the IDE.

Pinocchio: Bringing Reflection to Life with First-Class Interpreters

To support development tools like debuggers, runtime systems need to provide a meta-programming interface to alter their semantics and access internal data. Reflective capabilities are typically fixed by the Virtual Machine (VM). Unanticipated reflective features must either be simulated by complex program transformations, or they require the development of a specially tailored VM. We propose a novel approach to behavioral reflection that eliminates the barrier between applications and the VM by manipulating an explicit tower of first-class interpreters. Pinocchio is a proof-of-concept implementation of our approach which enables radical changes to the interpretation of programs by explicitly instantiating subclasses of the base interpreter. We illustrate the design of Pinocchio through non-trivial examples that extend runtime semantics to support debugging, parallel debugging, and back-in-time object-flow debugging. Although performance is not yet addressed, we also discuss numerous opportunities for optimization, which we believe will lead to a practical approach to behavioral reflection.

Modeling Features at Runtime

A feature represents a functional requirement fulfilled by a system. Since many maintenance tasks are expressed in terms of features, it is important to establish the correspondence between a feature and its implementation in source code. Traditional approaches to establish this correspondence exercise features to generate a trace of runtime events, which is then processed by post-mortem analysis. These approaches typically generate large amounts of data to analyze. Due to their static nature, these approaches do not support incremental and interactive analysis of features. We propose a radically different approach called live feature analysis, which provides a model at runtime of features. Our approach analyzes features on a running system and also makes it possible to grow feature representations by exercising different scenarios of the same feature, and identifies execution elements even to the sub-method level. We describe how live feature analysis is implemented effectively by annotating structural representations of code based on abstract syntax trees. We illustrate our live analysis with a case study where we achieve a more complete feature representation by exercising and merging variants of feature behavior and demonstrate the efficiency or our technique with benchmarks.

Domain-Specific Program Checking

Lint-like program checkers are popular tools that ensure code quality by verifying compliance with best practices for a particular programming language. The proliferation of internal domain-specific languages and models, however, poses new challenges for such tools. Traditional program checkers produce many false positives and fail to accurately check constraints, best practices, common errors, possible optimizations and portability issues particular to domain-specific languages. We advocate the use of dedicated rules to check domain-specific practices. We demonstrate the implementation of domain-specific rules, the automatic fixing of violations, and their application to two case-studies: (1) Seaside defines several internal DSLs through a creative use of the syntax of the host language; and (2) Magritte adds meta-descriptions to existing code by means of special methods. Our empirical validation demonstrates that domain-specific program checking significantly improves code quality when compared with general purpose program checking.

Run-Time Evolution through Explicit Meta-Objects

Software must be constantly adapted due to evolving domain knowledge and unanticipated requirements changes. To adapt a system at run-time we need to reflect on its structure and its behavior. Object-oriented languages introduced reflection to deal with this issue, however, no reflective approach up to now has tried to provide a unified solution to both structural and behavioral reflection. This paper describes Albedo, a unified approach to structural and behavioral reflection. Albedo is a model of fined-grained unanticipated dynamic structural and behavioral adaptation. Instead of providing reflective capabilities as an external mechanism we integrate them deeply in the environment. We show how explicit meta-objects allow us to provide a range of reflective features and thereby evolve both application models and environments at run-time.

Using Smalltalk as a Reflective Executable Meta-Language

Object-oriented meta-languages such as MOF or EMOF are often used to specify domain specific languages. However, these meta-languages lack the ability to describe behavior or operational semantics. Several approaches used a subset of Java mixed with OCL as executable meta-languages. In this paper, we report our experience of using Smalltalk as an executable and integrated meta-language. We validated this approach in incrementally building over the last decade, Moose, a meta-described reengineering environment. The reflective capabilities of Smalltalk support a uniform way of letting the base developer focus on his tasks while at the same time allowing him to meta-describe his domain model. The advantage of our this approach is that the developer uses the same tools and environment