An API response can match its schema while exposing another user’s data or failing to record a required audit event. This paper defines a compact policy-contract profile for testing access-control and selected privacy obligations in service APIs. The profile embeds required fields and optional dependent clauses in OpenAPI, relates them to authorization and privacy standards, and organizes coverage into four cumulative profiles. A compiler turns each declared obligation into a test case and a check of the relevant response, state change, audit event, or endpoint lifecycle behavior. In a controlled synthetic benchmark based on 12 policy templates, the generated checks detect the same injected faults as separately implemented handwritten assertions. The generated suite produces no false alerts on 5520 compliant evidence variations. Executions on VAmPI and OWASP crAPI detect seven documented defects without alerts on five controls. These results support the feasibility of generating traceable policy tests from interface contracts. The assurance remains limited to the obligations recorded in the contract and the evidence available to check them.
Digital Twins (DTs) have transformed industries by enabling virtual representations of physical systems, yet user interaction with these systems remains a critical and under-examined challenge. This paper reports a systematic review, conducted under PRISMA 2020 guidelines, of 55 peer-reviewed studies published between 2019 and 2024 at the intersection of Digital Twins and user interaction. The corpus spans manufacturing, urban infrastructure, healthcare, energy, agriculture, construction and smart-home applications, and covers conceptual frameworks, technical architectures, prototypes and user-evaluation studies. The synthesis characterises included studies by application domain, DT type in the Kritzinger et al. (2018) model–shadow–twin taxonomy, interaction modality, and reported user-evaluation approach. Across the corpus we find that: (i) only a minority of studies report any form of user involvement in requirements elicitation, participatory design, or post-deployment evaluation; (ii) validated usability instruments (SUS, UEQ, NASA-TLX) are used only sporadically; (iii) immersive AR/VR interaction is the most frequently reported modality but is dominated by technical demonstrations rather than controlled user studies; and (iv) recurring, cross-domain obstacles are data overload, interoperability across heterogeneous data sources, simulation sickness, and the absence of standardised interaction and evaluation frameworks. The review proposes a research roadmap (Section 5.4) that ties each direction to a specific evidence gap: user-centric and participatory design methodologies, standardised interaction and evaluation frameworks, cross-domain research on data visualisation and interoperability, and validated advances in AR/VR to support end-user decision-making. Limitations of the review itself — including its single-primary-reviewer coding, English-language and Scopus-dominant sourcing, and narrative rather than quantitative synthesis — are discussed in Section 5.5.
The injection of monitoring code enables real-time observation of program execution and has proven effective for analysis tools (a.k.a. profilers) that assist developers with tasks such as memory allocation tracking, performance optimization, and debugging. Message-passing control is an instrumentation paradigm that allows the execution of specific code before, after, or instead of each method invocation. In object-oriented languages, where computation is driven by message sending (late-bound method invocation), message-passing control is fundamental for implementing analysis tools. A key challenge is that the instrumentation itself may call instrumented methods, potentially leading to infinite recursions. Moreover, instrumentation typically introduces runtime overhead that distorts measurements and may render the instrumented system barely usable. For this reason, message-passing control must be meta-safe, to prevent infinite recursion within instrumented methods, while maintaining a practical overhead. In this article, we introduce METHODPROxIES, a per-method instrumentation library implemented in Pharo. It achieves a practical overhead (as low as 1.04 & times; in some benchmarks and 1.54 & times; on average) while guaranteeing meta-safety. Over the years, METHODPROxIES has been successfully used to build advanced memory profilers, method call graphs, and other analysis tools applied to a wide range of applications. We present an empirical evaluation of METHODPROxIES, analyzing its overhead, the cost of its meta-safety mechanism, and its integration with JIT compiler using real-world applications as benchmarks. Our results show that METHODPROxIES can be used effectively in real-world applications, providing an infrastructure that supports the implementation of advanced profilers with a practical overhead.
Source code does not exist in isolation. Code is structured in project repositories composed of packages, and large applications are often composed of multiple projects. This paper investigates whether token-level completion engines can take advantage of such information.In this context, Pharo offers a sophisticated completion engine based on language semantics using heuristics, i.e., ordered sequences of lazy fetchers that retrieve and rank completion candidates. These heuristics can be recomposed or extended to support various activities (e.g., live programming or history usage navigation). The default heuristics rely on the language’s semantics and scoping rules. While this system is powerful, it does not account for package concerns of any sort (neither repository structure nor package dependencies). As a result, it does not prioritize classes within the same package or project, nor the classes that they may use, treating all global names equally.In this paper, we introduce and systematically evaluate several new heuristics that address this limitation: Lateral Packages, Direct Package Dependencies, and Two-Level Package Dependencies heuristics. Our benchmark runs over the method call sites of 219 packages, comprising 4,535 classes and a total of 35,972 methods. This codebase covers major projects such as Iceberg, Moose, Roassal, Seaside, and Spec, ensuring a diverse and realistic benchmark for assessing the effectiveness of our proposed heuristics. We evaluate two key concerns: the completion of class and method names. Rather than proposing a new learning model, this work evaluates whether explicit package dependencies, already available in modular software systems, can serve as a lightweight structural signal for improving completion ranking.Results show that the Direct Package Dependencies heuristic improves Mean Reciprocal Rank (MRR): for 3-character prefixes, MRR increases from 0.20 to 0.44 for class-name completion and from 0.10 to 0.41 for method-name completion. These results indicate that package-aware completion strategies provide more accurate and relevant suggestions than the default Semantics-Based strategy in the evaluated projects. Because Direct Package Dependencies outperformed the default strategy for class-name completion, the Pharo Industrial Consortium decided to introduce it in Pharo 13.
