Christian Albrecht, Jule Böhmer, Stefanie Claußen
et al.
Vor dem Hintergrund digitaler Transformationsprozesse ist die schulische Ausbildung adäquater Kompetenzen für die Teilhabe im 21. Jahrhundert von großer Bedeutung. Dabei werden die 4K (Kommunikation, Kollaboration, kritisches Denken, Kreativität) als zentrale Kompetenzen angesehen und von den Kultusministerien in der Schule eingefordert. Wie aber kann eine Implementierung von 4K in einer zeitgemäßen schulischen Lern- und Prüfungskultur gelingen? Mit dieser Frage befasst sich das Modellprojekt LuPe² an neun Schulen verschiedener Schulformen. Dabei wurden im Rahmen einer Mixed-Methods-Studie qualitative Daten von Lehrkräften (N = 8 bis 25) und quantitative Daten von Schüler:innen (N = 186 bis 214) in einem Prä-Post-Design kombiniert.
Maßnahmen zur Förderung der 4K spiegelten sich in vielfältiger Weise in der Unterrichtsgestaltung wider, etwa durch offene Aufgabenformate, metakognitive Reflexionsphasen, medial vielfältige Kommunikationsformen und kollaborative Lernsettings. Gleichzeitig zeigte sich, dass standardisierte Prüfungsformate die Umsetzung dieser Kompetenzen nur begrenzt unterstützen, wodurch deutlich wird, dass eine nachhaltige Implementierung der 4K als Querschnittsaufgabe im Fach Deutsch nicht nur methodische Anpassungen im Unterricht erfordert, sondern auch strukturelle Veränderungen in der Prüfungskultur.
Abstract (English): 21st Century Skills as a cross-sectional task - The project ‘Developing and Researching a Contemporary Learning and Assessment Culture’ (LuPe²) from the perspective of German language education.
In the context of digital transformation processes, the development of adequate skills in schools is of crucial importance for participation in the 21st century. Accordingly, the 4Cs – Communication, Collaboration, Critical Thinking, and Creativity – are regarded as essential competencies and are actively promoted by ministries of education in schools. But how can the implementation of the 4Cs succeed within a contemporary culture of learning and assessment in schools? This question is addressed by the model project LuPe², which is being conducted at nine schools of various types. Using a mixed-methods approach, the project combines qualitative data from teachers (n = 8 to 25) and quantitative data from students (n = 186 to 214) within a pre-post design.
Measures to foster the 4Cs were reflected in diverse ways – for instance, through open-ended tasks, metacognitive reflection phases, varied forms of media-based communication, and collaborative learning environments. At the same time, it became apparent that standardized assessment formats only offer limited support for the implementation of these competencies. This highlights that the sustainable integration of the 4Cs as a cross-sectional task in the German language classroom requires not only methodological adjustments in teaching but also structural changes in the assessment culture.
Ensuring that API implementations and usage comply with natural language programming rules is critical for software correctness, security, and reliability. Formal verification can provide strong guarantees but requires precise specifications, which are difficult and costly to write manually. To address this challenge, we present Doc2Spec, a multi-agent framework that uses LLMs to automatically induce a specification grammar from natural-language rules and then generates formal specifications guided by the induced grammar. The grammar captures essential domain knowledge, constrains the specification space, and enforces consistent representations, thereby improving the reliability and quality of generated specifications. Evaluated on seven benchmarks across three programming languages, Doc2Spec outperforms a baseline without grammar induction and achieves competitive results against a technique with a manually crafted grammar, demonstrating the effectiveness of automated grammar induction for formalizing natural-language rules.
Nikolaus Huber, Susanne Graf, Philipp Rümmer
et al.
This paper introduces the Mimosa language, a programming language for the design and implementation of asynchronous reactive systems, describing them as a collection of time-triggered processes which communicate through FIFO buffers. Syntactically, Mimosa builds upon the Lustre data-flow language, augmenting it with a new semantics to allow for the expression of side-effectful computations, and extending it with an asynchronous coordination layer which orchestrates the communication between processes. A formal semantics is given to both the process and coordination layer through a textual and graphical rewriting calculus, respectively, and a prototype interpreter for simulation is provided.
Static verification provides strong correctness guarantees for code; however, fully specifying programs for static verification is a complex, burdensome process for users. Gradual verification was introduced to make this process easier by supporting the verification of partially specified programs. The only currently working gradual verifier, Gradual C0, successfully verifies heap manipulating programs, but lacks expressiveness in its specification language. This paper describes the design and implementation of an extension to Gradual C0 that supports unfolding expressions, which allow more intuitive specifications of recursive heap data structures.
In the Anthropocene, the era in which humans dominate the ecosystems, Charlotte Mutsaers, a Dutch writer and artist, uses her works (literature and paintings) to shift the anthropocentric narrative towards animals. Barbara Fraipont’s book, Mutsaers en andere dieren: Naar een diergerichte benadering in de Nederlandse letterkunde (2023), explores the representation of animals in Mutsaers works. The study examines the presence of animals as a central theme and critical paradigm in Mutsaers’ oeuvre. The book’s accessible structure and rich theoretical background make it a significant contribution to animal studies in Dutch literature.
Conventional Western theatre is based on the Aristotelian notion of presence. Contemporary theatre, however, proposes an aesthetic of absence. Its orientation differs from the notion of presence found in text-centred Western theatre. This aesthetic model, adopted by contemporary theatre since the 1990s, also appears in various forms in current productions based on digital dramaturgies. Rimini Protokoll, a German theatre company with many experimental approaches, presents an anti-theatrical aesthetic based on absence. This study analyses Rimini Protokoll’s 2018 Unheimliches Tal / Uncanny Valley in terms of removing the human actor from the centre and replacing him with an animatronic robot. This production, which stands out as one of the most striking examples of digital theatre, erases the presence of the human actor on stage with an animatronic copy, proposing an uncanny theatricality that oscillates between presence and absence. To understand how this theatricality is constructed, the concept of the uncanny is analysed in the introductory part of the article through the metaphor of the “uncanny valley.” Subsequently, the academic literature on theatre and the notion of the uncanny is presented, with a particular focus on the metaphor of the ghost. The following section presents Jacques Derrida’s views onWestern theatre, focusing on his concepts of the metaphysics of presence, logocentrism, and hauntology. The article examines Unheimliches Tal / Uncanny Valley in the context of those concepts and then concludes with a consideration of the theatricality of this production in relation to contemporary theatre productions and digital dramaturgies.
German literature, Germanic languages. Scandinavian languages
We study the question of which visibly pushdown languages (VPLs) are in the complexity class $\mathsf{AC}^0$ and how to effectively decide this question. Our contribution is to introduce a particular subclass of one-turn VPLs, called intermediate VPLs, for which the raised question is entirely unclear: to the best of our knowledge our research community is unaware of containment or non-containment in $\mathsf{AC}^0$ for any language in our newly introduced class. Our main result states that there is an algorithm that, given a visibly pushdown automaton, correctly outputs either that its language is in $\mathsf{AC}^0$, outputs some $m\geq 2$ such that $L$ is $\mathsf{ACC}^0(m)$-hard (implying that $L$ is not in $\mathsf{AC}^0$), or outputs a finite disjoint union of intermediate VPLs that $L$ is constant-depth equivalent to. In the latter case one can moreover effectively compute $k,l\in\mathbb{N}_{>0}$ with $k\not=l$ such that the concrete intermediate VPL $L(S\rightarrow\varepsilon\mid a c^{k-1} S b_1\mid ac^{l-1}Sb_2)$ is constant-depth reducible to the language $L$. Due to their particular nature we conjecture that either all intermediate VPLs are in $\mathsf{AC}^0$ or all are not. As a corollary of our main result we obtain that in case the input language is a visibly counter language our algorithm can effectively determine if it is in $\mathsf{AC}^0$ -- hence our main result generalizes a result by Krebs et al. stating that it is decidable if a given visibly counter language is in $\mathsf{AC}^0$ (when restricted to well-matched words). For our proofs we revisit so-called Ext-algebras (introduced by Czarnetzki et al.), which are closely related to forest algebras (introduced by Bojańczyk and Walukiewicz), and use Green's relations.
The Isabelle proof assistant includes a small functional language, which allows users to write and reason about programs. So far, these programs could be extracted into a number of functional languages: Standard ML, OCaml, Scala, and Haskell. This work adds support for Go as a fifth target language for the Code Generator. Unlike the previous targets, Go is not a functional language and encourages code in an imperative style, thus many of the features of Isabelle's language (particularly data types, pattern matching, and type classes) have to be emulated using imperative language constructs in Go. The developed Code Generation is provided as an add-on library that can be simply imported into existing theories.
This paper investigates the expression of grammatical gender in Heritage Argentine Danish. We examine a subset of the Corpus of South American Danish of approximately 20,500 tokens of gender marking produced by 90 speakers. The results show that Argentine Danish gender marking in general complies with the Standard Denmark Danish rules. However, there is also systematic variation: While there is hardly any difference compared to Standard Denmark Danish with respect to the definite suffix, gender marking on prenominal determiners differs from that in Standard Danish. More specifically, the less frequent neuter gender is more vulnerable, and common gender tends to be overgeneralized. Further, complex NPs with attributive adjectives show more variation in gender marking on prenominal determiners than simple NPs. As to sociolinguistic variation, the analysis shows that tokens produced by older speakers and speakers from settlements with a higher degree of language maintenance are consistent to a higher degree with Standard Danish gender marking. The paper compares these results with the results of studies of gender marking variation in other Germanic heritage languages. We conclude that the overall stability of grammatical gender in the Germanic heritage languages is a general pattern that only partly relates to social or societal factors.*
In 2011 the Groot Woordenboek Afrikaans en Nederlands (Large Dictionary Afrikaans and Dutch), commonly known as ANNA, appeared. Contrary to so-called difference dictionaries, bilingual dictionaries of narrowly related languages which describe only differences between the two languages, ANNA describes both differences and similarities between Afrikaans and Dutch, not only on the semantic level but on the combinatorial and pragmatic level as well. In this sense ANNA is a unique project, based on an original amalgamation model. In this article first some background information will be given about the ANNA project and its results, followed by a presentation of the underlying model and an evaluation of it.
Philology. Linguistics, Languages and literature of Eastern Asia, Africa, Oceania
We demonstrate the utility of the Multi-Level Intermediate Representation (MLIR) for quantum computing. Specifically, we extend MLIR with a new quantum dialect that enables the expression and compilation of common quantum assembly languages. The true utility of this dialect is in its ability to be lowered to the LLVM intermediate representation (IR) in a manner that is adherent to the quantum intermediate representation (QIR) specification recently proposed by Microsoft. We leverage a qcor-enabled implementation of the QIR quantum runtime API to enable a retargetable (quantum hardware agnostic) compiler workflow mapping quantum languages to hybrid quantum-classical binary executables and object code. We evaluate and demonstrate this novel compiler workflow with quantum programs written in OpenQASM 2.0. We provide concrete examples detailing the generation of MLIR from OpenQASM source files, the lowering process from MLIR to LLVM IR, and ultimately the generation of executable binaries targeting available quantum processors.
It is well known that for a regular tree language it is decidable whether or not it can be recognized by a deterministic top-down tree automaton (DTA). However, the computational complexity of this problem has not been studied. We show that for a given deterministic bottom-up tree automaton it can be decided in quadratic time whether or not its language can be recognized by a DTA. Since there are finite tree languages that cannot be recognized by DTAs, we also consider finite unions of \DTAs and show that also here, definability within deterministic bottom-up tree automata is decidable in quadratic time.
Luís Cruz-Filipe, Fabrizio Montesi, Marco Peressotti
Theory of choreographic languages typically includes a number of complex results that are proved by structural induction. The high number of cases and the subtle details in some of them lead to long reviewing processes, and occasionally to errors being found in published proofs. In this work, we take a published proof of Turing completeness of a choreographic language and formalise it in Coq. Our development includes formalising the choreographic language and its basic properties, Kleene's theory of partial recursive functions, the encoding of these functions as choreographies, and proving this encoding correct. With this effort, we show that theorem proving can be a very useful tool in the field of choreographic languages: besides the added degree of confidence that we get from a mechanised proof, the formalisation process led us to a significant simplification of the underlying theory. Our results offer a foundation for the future formal development of choreographic languages.
Reo is a formal coordination language. In order to assess and evaluate its capabilities, we need a multi-perspective Language Evaluation Framework. Langar (Language Analysis for Reo) is a framework aimed to provide such an evaluation method. In this paper, we introduce Langar. Based on a review on various language evaluation methods, a tool-kit for useful evaluation techniques are provided. After Reo Evaluation, this method and tool-kit also could be used for another programming, computational and even natural languages. Furthermore, two suggestions for some future efforts and directions are provided for software engineering and software methodology communities.
The editorial team greatly appreciates the reviewers who have dedicated their considerable time and expertise to the journal’s rigorous editorial process over the past 12 months, regardless of whether the papers are finally published or not [...]
A theory of data types based on category theory is presented. We organize data types under a new categorical notion of F,G-dialgebras which is an extension of the notion of adjunctions as well as that of T-algebras. T-algebras are also used in domain theory, but while domain theory needs some primitive data types, like products, to start with, we do not need any. Products, coproducts and exponentiations (i.e. function spaces) are defined exactly like in category theory using adjunctions. F,G-dialgebras also enable us to define the natural number object, the object for finite lists and other familiar data types in programming. Furthermore, their symmetry allows us to have the dual of the natural number object and the object for infinite lists (or lazy lists). We also introduce a programming language in a categorical style using F,G-dialgebras as its data type declaration mechanism. We define the meaning of the language operationally and prove that any program terminates using Tait's computability method.
Michail Papadimitriou, Juan Fumero, Athanasios Stratikopoulos
et al.
In recent years, heterogeneous computing has emerged as the vital way to increase computers? performance and energy efficiency by combining diverse hardware devices, such as Graphics Processing Units (GPUs) and Field Programmable Gate Arrays (FPGAs). The rationale behind this trend is that different parts of an application can be offloaded from the main CPU to diverse devices, which can efficiently execute these parts as co-processors. FPGAs are a subset of the most widely used co-processors, typically used for accelerating specific workloads due to their flexible hardware and energy-efficient characteristics. These characteristics have made them prevalent in a broad spectrum of computing systems ranging from low-power embedded systems to high-end data centers and cloud infrastructures. However, these hardware characteristics come at the cost of programmability. Developers who create their applications using high-level programming languages (e.g., Java, Python, etc.) are required to familiarize with a hardware description language (e.g., VHDL, Verilog) or recently heterogeneous programming models (e.g., OpenCL, HLS) in order to exploit the co-processors? capacity and tune the performance of their applications. Currently, the above-mentioned heterogeneous programming models support exclusively the compilation from compiled languages, such as C and C++. Thus, the transparent integration of heterogeneous co-processors to the software ecosystem of managed programming languages (e.g. Java, Python) is not seamless. In this paper we rethink the engineering trade-offs that we encountered, in terms of transparency and compilation overheads, while integrating FPGAs into high-level managed programming languages. We present a novel approach that enables runtime code specialization techniques for seamless and high-performance execution of Java programs on FPGAs. The proposed solution is prototyped in the context of the Java programming language and TornadoVM; an open-source programming framework for Java execution on heterogeneous hardware. Finally, we evaluate the proposed solution for FPGA execution against both sequential and multi-threaded Java implementations showcasing up to 224x and 19.8x performance speedups, respectively, and up to 13.82x compared to TornadoVM running on an Intel integrated GPU. We also provide a break-down analysis of the proposed compiler optimizations for FPGA execution, as a means to project their impact on the applications? characteristics.