Hasil untuk "Germanic languages. Scandinavian languages"

Debasish Dutta, Neeharika Sonowal, Irani Hazarika

The paper introduces the development of a modular compiler for a subset of a C-like language, which addresses the challenges in constructing a compiler for high-level languages. This modular approach will allow developers to modify a language by adding or removing subsets as required, resulting in a minimal and memory-efficient compiler. The development process is divided into small, incremental steps, where each step yields a fully functioning compiler for an expanding subset of the language. The paper outlines the iterative developmental phase of the compiler, emphasizing progressive enhancements in capabilities and functionality. Adherence to industry best practices of modular design, code reusability, and documentation has enabled the resulting compiler's functional efficiency, maintainability, and extensibility. The compiler proved to be effective not only in managing the language structure but also in developing optimized code, which demonstrates its practical usability. This was also further assessed using the compiler on a tiny memory-deficient single-board computer, again showing the compiler's efficiency and suitability for resource-constrained devices.

Klaus Jansen, Dirk Nowotka, Lis Pirotton et al.

Patterns are words with terminals and variables. The language of a pattern is the set of words obtained by uniformly substituting all variables with words that contain only terminals. In their original definition, patterns only allow for multiple distinct occurrences of some variables to be related by the equality relation, represented by using the same variable multiple times. In an extended notion, called relational patterns and relational pattern languages, variables may be related by arbitrary other relations. We extend the ongoing investigation of the main decision problems for patterns (namely, the equivalence problem, the inclusion problem, and the membership problem) to relational pattern languages under a wide range of relevant individual relations, providing a comprehensive foundation in all three research directions.

Smayan Agarwal, Aalok Thakkar

When does a deterministic computational model define a probability distribution? What are its properties? This work formalises and settles this stochasticity problem for weighted automata, and its generalisation cost register automata (CRA). We show that checking stochasticity is undecidable for CRAs in general. This motivates the study of the fully linear fragment, where a complete and tractable theory is established. For this class, stochasticity becomes decidable in polynomial time via spectral methods, and every stochastic linear CRA admits an equivalent model with locally sub-stochastic update functions. This provides a local syntactic characterisation of the semantics of the quantitative model. This local characterisation allows us to provide an algebraic Kleene-Schutzenberger characterisation for stochastic languages. The class of rational stochastic languages is the smallest class containing finite support distributions, which is closed under convex combination, Cauchy product, and discounted Kleene star. We also introduce Stochastic Regular Expressions as a complete and composable grammar for this class. Our framework provides the foundations for a formal theory of probabilistic computation, with immediate consequences for approximation, sampling, and distribution testing.

Tina Otten, Sören Ohlhus

In der Auseinandersetzung mit (modellhaften) Texten zu bestimmten Textsorten können Schüler*innen Textprozeduren, d.h. Einheiten aus Sprachhandlungen (z.B. Temporalisieren) und sprachlichen Ausdrücken (z.B. vor langer, langer Zeit) kennenlernen und so ein ‚Gespür‘ für Textmuster und -funktionen sowie ihre sprachliche Gestaltung entwickeln – Textprozeduren können dann zu „Werkzeugen des eigenen Schreibens“ werden und die Textproduktion und -rezeption unterstützen (vgl. Feilke 2012; Feilke / Bachmann 2014; Feilke / Rezat 2020; Rezat 2022). Doch wie können diese Prozeduren und -ausdrücke im Schreibprozess für die Planung und sprachliche Umsetzung eigener Texte konkret verfügbar gemacht werden? Wie wirken sich prozessbegleitende digitale und analoge Hilfsmittel auf Schreibprozesse und -produkte von Schüler*innen aus? Im vorliegenden Beitrag werden Potentiale digitaler Mindmaps auf Tablets (im Vergleich zu analogen Lapbooks) für die Unterstützung von Schreibprozessen in der Primarstufe diskutiert. Dabei beziehen wir uns auf Beobachtungen aus einem explorativen Unterrichtsversuch, der im Rahmen des BMBF-geförderten Projekts Cu2RVE in drei vierten Klassen durchgeführt wurde.   Abstract (english): How to support the process of formulation in students‘ writing: Observations on the use of digital media when writing narrative texts By dealing with exemplary texts of certain text types, students can grasp text procedures, i. e. speech acts (e.g. temporalizing) and typical linguistic constructions (e.g. a long, long time ago), and thus develop a ‘feeling’ for text patterns and functions as well as their linguistic design - text procedures can then become “writing tools” which support text production and reception (cf. Feilke 2012, Feilke / Bachmann 2014, Feilke / Rezat 2020, Rezat 2022). But how can these procedures and expressions be made available during the writing process for the planning and linguistic implementation of one’s own texts? How do process-accompanying digital and analogue tools affect the writing processes and products of students? This article discusses the potential of digital mind maps on tablets (compared to analog lapbooks) to support writing processes in primary school. We refer to observations from an exploratory teaching experiment that was carried out in three fourth grades of primary schools as part of the BMBF-funded project Cu2RVE. 

Jan Dlask, Margita Gáborová

Daniel Alexander Spenner

The paper completely characterizes the primality of acyclic DFAs, where a DFA $\mathcal{A}$ is prime if there do not exist DFAs $\mathcal{A}_1,\dots,\mathcal{A}_t$ with $\mathcal{L}(\mathcal{A}) = \bigcap_{i=1}^{t} \mathcal{L}({\mathcal{A}_i})$ such that each $\mathcal{A}_i$ has strictly less states than the minimal DFA recognizing the same language as $\mathcal{A}$. A regular language is prime if its minimal DFA is prime. Thus, this result also characterizes the primality of finite languages. Further, the $\mathsf{NL}$-completeness of the corresponding decision problem $\mathsf{PrimeDFA}_{\text{fin}}$ is proven. The paper also characterizes the primality of acyclic DFAs under two different notions of compositionality, union and union-intersection compositionality. Additionally, the paper introduces the notion of S-primality, where a DFA $\mathcal{A}$ is S-prime if there do not exist DFAs $\mathcal{A}_1,\dots,\mathcal{A}_t$ with $\mathcal{L}(\mathcal{A}) = \bigcap_{i=1}^{t} \mathcal{L}(\mathcal{A}_i)$ such that each $\mathcal{A}_i$ has strictly less states than $\mathcal{A}$ itself. It is proven that the problem of deciding S-primality for a given DFA is $\mathsf{NL}$-hard. To do so, the $\mathsf{NL}$-completeness of $\mathsf{2MinimalDFA}$, the basic problem of deciding minimality for a DFA with at most two letters, is proven.

Iona Thomas, Vincent Aranega, Stéphane Ducasse et al.

In object-oriented languages, method visibility modifiers hold a key role in separating internal methods from the public API. Protected visibility modifiers offer a way to hide methods from external objects while authorizing internal use and overriding in subclasses. While present in main statically-typed languages, visibility modifiers are not as common or mature in dynamically-typed languages. In this article, we present ProtDyn, a self-send-based visibility model calculated at compile time for dynamically-typed languages relying on name-mangling and syntactic differentiation of self vs non self sends. We present #Pharo, a ProtDyn implementation of this model that is backwards compatible with existing programs, and its port to Python. Using these implementations we study the performance impact of ProtDyn on the method lookup, in the presence of global lookup caches and polymorphic inline caches. We show that our name mangling and double method registration technique has a very low impact on performance and keeps the benefits from the global lookup cache and polymorphic inline cache. We also show that the memory overhead on a real use case is between 2% and 13% in the worst-case scenario. Protected modifier semantics enforces encapsulation such as private but allow developers to still extend the class in subclasses. ProtDyn offers a VM-agnostic and backwards-compatible design to introduce protected semantics in dynamically-typed languages.

Ori Roth, Yossi Gil

Fluent API is an object-oriented pattern for elegant APIs and embedded DSLs. A smart fluent API can enforce the API protocol or DSL syntax at compile time. As fluent API designs typically rely on function overloading, they are hard to realize in functional programming languages. We show how to write functional fluent APIs using parametric polymorphism and type inference instead of overloading. Our designs support all regular and deterministic context-free API protocols and beyond.

Benjamin Chetioui, Jaakko Järvi, Magne Haveraaen

Context: Generic programming, as defined by Stepanov, is a methodology for writing efficient and reusable algorithms by considering only the required properties of their underlying data types and operations. Generic programming has proven to be an effective means of constructing libraries of reusable software components in languages that support it. Generics-related language design choices play a major role in how conducive generic programming is in practice. Inquiry: Several mainstream programming languages (e.g. Java and C++) were first created without generics; features to support generic programming were added later, gradually. Much of the existing literature on supporting generic programming focuses thus on retrofitting generic programming into existing languages and identifying related implementation challenges. Is the programming experience significantly better, or different when programming with a language designed for generic programming without limitations from prior language design choices? Approach: We examine Magnolia, a language designed to embody generic programming. Magnolia is representative of an approach to language design rooted in algebraic specifications. We repeat a well-known experiment, where we put Magnolia's generic programming facilities under scrutiny by implementing a subset of the Boost Graph Library, and reflect on our development experience. Knowledge: We discover that the idioms identified as key features for supporting Stepanov-style generic programming in the previous studies and work on the topic do not tell a full story. We clarify which of them are more of a means to an end, rather than fundamental features for supporting generic programming. Based on the development experience with Magnolia, we identify variadics as an additional key feature for generic programming and point out limitations and challenges of genericity by property. Grounding: Our work uses a well-known framework for evaluating the generic programming facilities of a language from the literature to evaluate the algebraic approach through Magnolia, and we draw comparisons with well-known programming languages. Importance: This work gives a fresh perspective on generic programming, and clarifies what are fundamental language properties and their trade-offs when considering supporting Stepanov-style generic programming. The understanding of how to set the ground for generic programming will inform future language design.

Christian Koch, Katharina Müller, Eldar Sultanow

There are numerous articles about the programming languages most commonly used by hackers. Among them, however, there are hardly any scientific studies. One reason might be that hackers mainly operate anonymously and are difficult to reach. This paper aims to shed light on this interesting and relevant research question. In order to find answers, we conducted a survey among the members of the German Chaos Computer Club. As one of the world's largest organisations for information security and hacking, the club provides a good basis for our study. We examine the question of which programming languages are used by hackers as well as the importance of the programming language for their work. The paper offers first insights into the topic and can provide a starting point for further research.

Seamus Brady

Many popular open source programming languages (Perl, Ruby or Python for example) have systems for distributing packaged source code that software developers can use when working in that particular programming language. This paper will consider the design principals that should be followed if designing such an open source code repository.

Elena Bratishenko, Larisa Leisiö

This issue of Scando-Slavica is devoted to the topic of morphosyntactic change in Russian in the light of language contact. It is the outcome of two linguistics panels at the 21 Conference of Scandinavian Slavists that took place in August 2019 at the University of Eastern Finland, Joensuu campus. The papers examine various aspects and possible morphosyntactic consequences of convergence during the development of the Russian language pointing to historical or prehistoric language contacts in the area of Northern East Slavic. While some papers deal with the phenomena that make Russian stand out against the background of even its closest relatives and may thus have been triggered by such contacts, others address broader issues and consider theoretical implications of contact phenomena, the specific contact configurations, and the interplay between internal and external factors in morphosyntactic processes. Andersen’s article addresses the origin and development of definiteness marking in the adjective phrase in Germanic, Baltic and Slavic, and considers three possible hypotheses of prehistoric bilingual language contact in various configurations, as well as areal convergence. The examination of the definite paradigms in all three language families at the earliest historical stages leads Andersen to the conclusion that they are archaisms rather than innovations. In the final analysis, Andersen prefers the idea of direct borrowing of definiteness marking from Germanic. He explains that contacts between Germanic, Baltic and Slavic went on for a very long time, occurring before the invasion of the Huns in 375 A.D. The Slavic and Baltic subordinators (the term he uses for the PIE pronoun *-yo attested in Indo-Iranian) changed into definite markers because of the contacts with East Germanic groups before then, and their spread continued thereafter. One part of Andersen’s article deals with the terminology and methodological issues of language contact. He elaborates on the idea of functional equivalence in language contact and stresses the importance of accounting for innovations on the level of the speaker in order to produce a realistic explanation of the process. Penkova investigates the problem of the periphrastic future formation with inchoative auxiliaries during the Middle Russian period. Leaning on

Daniel Ritter, Jan Broß

Although message-based (business) application integration is based on orchestrated message flows, current modeling languages exclusively cover (parts of) the control flow, while under-specifying the data flow. Especially for more data-intensive integration scenarios, this fact adds to the inherent data processing weakness in conventional integration systems. We argue that with a more data-centric integration language and a relational logic based implementation of integration semantics, optimizations from the data management domain(e.g., data partitioning, parallelization) can be combined with common integration processing (e.g., scatter/gather, splitter/gather). With the Logic Integration Language (LiLa) we redefine integration logic tailored for data-intensive processing and propose a novel approach to data-centric integration modeling, from which we derive the control-and data flow and apply them to a conventional integration system.

Jennifer Duggan, Anne Dahl

The transnational success of the Norwegian multimedia series SKAM is unique in the Scandinavian context and a prime example of how fans’ translation, communication, and dissemination practices can lead to a series’ international success. In this study, we argue that fan translation of SKAM emphasizes the value of bi-/multilinguality by positioning Norwegian as a resource within a transnational online community, while simultaneously masking the ways in which translation into English normalizes English as the global language of communication and contributes to the Anglo-American dominance of online global media fandom. Nonetheless, fans’ use of English as a lingua franca (ELF) positions it as a democratic resource, challenging native-speaker hegemony (cf. House 2013; Widdowson 1994), and fans’ online translation and dissemination of non-Anglo media into English are practices which subvert the very dominance they actualize, challenging the privileged status of English by carving out space for non-Anglo linguistic expertise and positioning linguistic knowledge and the multicompetent language user as valuable (cf. Cook 1991; Cook 1992). This also creates a digital space for valuing non-Anglo popular cultural objects, languages, and cultures.

Ari Páll Kristinsson

Theoretical analyses and models by Haugen (1966), Ammon (2003, 2015) and Spolsky (2004, 2009, 2018) on language standardization, language policy and language management are described and discussed, along with some detailed accounts on how these have been or may be used in the study of Icelandic language standardization and language policy at various points in the history of Icelandic. Furthermore, some advantages and shortcomings of these analyses are discussed in comparison with different theoretical approaches.

Michael Coblenz, Gauri Kambhatla, Paulette Koronkevich et al.

Programming language design requires making many usability-related design decisions. However, existing HCI methods can be impractical to apply to programming languages: they have high iteration costs, programmers require significant learning time, and user performance has high variance. To address these problems, we adapted both formative and summative HCI methods to make them more suitable for programming language design. We integrated these methods into a new process, PLIERS, for designing programming languages in a user-centered way. We evaluated PLIERS by using it to design two new programming languages. Glacier extends Java to enable programmers to express immutability properties effectively and easily. Obsidian is a language for blockchains that includes verification of critical safety properties. Summative usability studies showed that programmers were able to program effectively in both languages after short training periods.

Jens Oliver Gutsfeld, Markus Müller-Olm, Christian Dielitz

Computation Tree Logic (CTL) and its extensions CTL* and CTL+ are widely used in automated verification as a basis for common model checking tools. But while they can express many properties of interest like reachability, even simple regular properties like "Every other index is labelled a cannot be expressed in these logics. While many extensions were developed to include regular or even non-regular (e.g. visibly pushdown) languages, the first generic framework, Extended CTL, for CTL with arbitrary language classes was given by Axelsson et. al. and applied to regular, visibly pushdown and (deterministic) context-free languages. We extend this framework to CTL* and CTL+ and analyse it with regard to decidability, complexity, expressivity and satisfiability.

J. Algeo, Thomas Pyles

Krystian Suchorab

Janusz A. Brzozowski, Sylvie Davies, Abhishek Madan

In a simple pattern matching problem one has a pattern $w$ and a text $t$, which are words over a finite alphabet $Σ$. One may ask whether $w$ occurs in $t$, and if so, where? More generally, we may have a set $P$ of patterns and a set $T$ of texts, where $P$ and $T$ are regular languages. We are interested whether any word of $T$ begins with a word of $P$, ends with a word of $P$, has a word of $P$ as a factor, or has a word of $P$ as a subsequence. Thus we are interested in the languages $(PΣ^*)\cap T$, $(Σ^*P)\cap T$, $(Σ^* PΣ^*)\cap T$, and $(Σ^* \mathbin{\operatorname{shu}} P)\cap T$, where $\operatorname{shu}$ is the shuffle operation. The state complexity $κ(L)$ of a regular language $L$ is the number of states in the minimal deterministic finite automaton recognizing $L$. We derive the following upper bounds on the state complexities of our pattern-matching languages, where $κ(P)\le m$, and $κ(T)\le n$: $κ((PΣ^*)\cap T) \le mn$; $κ((Σ^*P)\cap T) \le 2^{m-1}n$; $κ((Σ^*PΣ^*)\cap T) \le (2^{m-2}+1)n$; and $κ((Σ^*\mathbin{\operatorname{shu}} P)\cap T) \le (2^{m-2}+1)n$. We prove that these bounds are tight, and that to meet them, the alphabet must have at least two letters in the first three cases, and at least $m-1$ letters in the last case. We also consider the special case where $P$ is a single word $w$, and obtain the following tight upper bounds: $κ((wΣ^*)\cap T_n) \le m+n-1$; $κ((Σ^*w)\cap T_n) \le (m-1)n-(m-2)$; $κ((Σ^*wΣ^*)\cap T_n) \le (m-1)n$; and $κ((Σ^*\mathbin{\operatorname{shu}} w)\cap T_n) \le (m-1)n$. For unary languages, we have a tight upper bound of $m+n-2$ in all eight of the aforementioned cases.