As software continues to permeate nearly every facet of modern life, the complexity and ubiquity of digital services underscore the need for sustainable, effective, and inclusive software development practices.Although software engineering has made significant progress in technical challenges since its inception, the human experience of those involved in software creation, broadly defined as developers, remains underexplored.This column advocates for the formal recognition of Developer eXperience (DevX) as a distinct research field.We argue that DevX profoundly influences critical development activities and overall productivity, especially as development becomes increasingly collaborative and diverse in terms of application domains.Building on existing efforts to measure and enhance DevX, we identify key rationales, scientific enablers, and interdisciplinary intersections that support this emerging discipline.We also outline the core scientific challenges ahead, aiming to call for actions from the research community and to promote more human-centered approaches to software engineering.

We define the layered architectural style as an architectural pattern and a structuring method in terms of precise specifications of interface behavior and modular composition, based on a formal model.Interface predicates and interface assertions are used to specify the interface behavior of systems, which is a description of the services that they require and provide.We give both a syntactic and a semantic description of the design pattern of layered system architectures.Moreover, we prove that the composition of multiple layers also generates layers, subject to the condition that the services provided by lower layers are refinements of the required services of upper layers.We demonstrate the approach by examples.We seek two goals: (a) to give a precise semantic characterization of the concept of layered architectures, and (b) to provide a method for specifying and for structuring layered system architectures.We show how to decompose services as offered and used by layered architectures into encapsulated subservices called functional features.A related issue is the identification of feature interactions between these subservices.Feature interactions between functional features can be identified by studying their interface behavior.A number of small examples is given to illustrate the introduced notions and concept.

In this preface, the editors present an overview of the topics and scope of the workshop on Verification and Monitoring at Runtime Execution (VORTEX) and describe the editorial and reviewing process for its edition at ECOOP 2022. The papers selected for publication are presented and briefly described.

Offline runtime verification involves the static analysis of executions of a system against a specification. For distributed systems, it is generally not possible to characterize executions in the form of global traces, given the absence of a global clock. To account for this, we model executions as collections of local traces called multi-traces, with one local trace per group of co-localized actors that share a common clock. Due to the difficulty of synchronizing the start and end of the recordings of local traces, events may be missing at their beginning or end. Considering such partially observed multi-traces is challenging for runtime verification. To that end, we propose an algorithm that verifies the conformity of such traces against formal specifications called Interactions (akin to Message Sequence Charts). It relies on parameterized simulation to reconstitute unobserved behaviors.

In this preface, we present an overview of the topics and scope of the European Conference on Modelling Foundations and Applications (ECMFA) and describe the editorial and reviewing process for its 20 th edition (ECMFA 2024).

The engineering of hierarchically decomposed component-based systems emphasizes the separation of concerns to reduce development complexity through work distribution and component reuse.Variability further promotes reuse, as system variants may be used in different markets or contexts.However, variability must be adequately managed as it introduces another layer of complexity to system development.Consequently, modeling of hierarchical component-based systems should support composition of variable components while simultaneously facilitating their formal analysis.To address this, we formally define variable component types, propose a modeling language for specifying the variability of hierarchically composed systems, and present a method to check the component variants' well-formedness.We extend the semantically grounded architecture description language MontiArc to realize the modeling of variable component-based systems supporting the well-formedness of variable component types and late binding of variability.The resulting realization of variable component types enables the specification of reusable and flexible components while making customization options explicit in the component interface and maintaining the black-box view of components.This can ultimately reduce complexity in developing variable components and, thus, facilitate the engineering of component-based systems.

Although fuzzers have been successful in revealing semantic bugs that lead to crashes, they do not reveal semantic bugs that do not lead to crashes.Furthermore, the inputs that lead to crashes may be invalid and invalid inputs do not reveal semantic bugs at all, since they are outside the program's intended input domain.On the other hand, runtime assertion checking (RAC) may be used for revealing semantic bugs, although it needs input test data that can trigger these bugs.In this idea paper, we propose the idea of combining different kinds of fuzzing tools and RAC in a complementary manner to leverage their benefits and overcome these problems, along with a preliminary study.That is, a fuzzing tool will generate an input test, and a RAC tool will make sure that the generated inputs are valid and check the results for semantic bugs.

A domain-specific language (DSL) can have multiple syntaxes, that can be graphical or textual. When modelling the behaviour, complex expressions, and fine details of a domain, often it does not make sense to use a graphical syntax, as this can result in large, crowded diagrams, therefore in such cases, a textual syntax is often more appropriate. As such, the best of both worlds can be delivered by a DSL that has hybrid (part-graphical and part-textual) syntaxes. In this work, we address open challenges and apply model-driven engineering techniques to streamline the development of hybrid graphical-textual model editors for DSLs, by using as little hand-written code as possible.

While developers and users of modern software systems usually only need to interact with a specific part of the system at a time, they are hindered by the ever-increasing complexity of the entire system. Views are projections of underlying models and can be employed to abstract from that complexity. When a view is modified, the changes must be propagated back into the underlying model without overriding simultaneous modifications. Hence, the view needs to provide a fine-grained sequence of changes to update the model minimally invasively. Such fine-grained changes are often unavailable for views that integrate with existing workflows and tools. To this end, model differencing approaches can be leveraged to compare two states of a view and derive an estimated change sequence. However, these model differencing approaches are not intended to operate with views, as their correctness is judged solely by comparing the input models. For views, the changes are derived from the view states, but the correctness depends on the underlying model. This work introduces a refined notion of correctness for change sequences in the context of model-view consistency. Furthermore, we evaluate state-of-the-art model differencing regarding model-view consistency. Our results show that model differencing largely performs very well. However, incorrect change sequences were derived for two common refactoring operation types, leading to an incorrect model state. These types can be easily reproduced and are likely to occur in practice. By considering our change sequence properties in the view type design, incorrect change sequences can be detected and semi-automatically repaired to prevent such incorrect model states.