What if the future of software architecture doesn’t need architects as we know them? As GenAI infiltrates every stage of the software development lifecycle, the traditional role of the architect—meticulously designing systems from requirements to deployment—is being unbundled, redefined, and partially outsourced to machines. And yet, the industry is far from ready. This keynote presents a bold vision of the AI-Augmented Architect: a hybrid thinker who doesn’t write blueprints alone but designs with AI, using it not as a tool—but as a creative partner, a challenger, a simulator of trade-offs. Drawing from two cutting-edge empirical studies, including a multivocal review of GenAI in software architecture and a forward-looking survey of industry leaders, we’ll confront hard truths: AI is already doing architectural documentation, detecting antipatterns, and even suggesting design alternatives. But it’s also hallucinating, biasing decisions, and eroding accountability. If we don’t rethink our roles, methods, and mindset, software architects risk becoming passive validators of AI output rather than strategic designers of complex systems. The good news? There is still time to adapt—but only if we embrace a future where architecture is not less human, but more profoundly human because of our collaboration with machines.

Rust is a modern language that guarantees memory-safety while supporting low-level concepts similar to C and C++. Particularly, it has a built-in feature-expression language and allows for configuring the usage of Rust crates (libraries) used in other Rust projects. Yet the variability in the Rust ecosystem remains largely undiscovered leaving developers confronted with several issues such as including too many unnecessary features, feature versioning, and possible feature interactions. In our talk, we demonstrate how to analyze the variability inherent in single Rust crates. We show how a feature model can be synthesized by different Rust configurations (selection of features of a used Rust library in another Rust project) using an FCA based method. We analyze the resulting feature models to understand the size of the configuration space and the usage of features among Rust libraries.

Quantum computing improves substantially on known classical algorithms for various important problems, but the nature of the relationship between quantum and classical computing is not yet fully understood. This relationship can be clarified by free models, that add to classical computing just enough physical principles to represent quantum computing and no more. In this talk, I will describe an axiomatisation of quantum computing that replaces the standard continuous postulates with a small number of discrete equations, as well as a free model that replaces the standard linear-algebraic model with a category-theoretical one. The axioms and model are based on reversible classical computing, isolate quantum advantage in the ability to take certain well-behaved square roots, and link to various quantum computing hardware platforms. This approach allows combinatorial optimisation, including brute force computer search, to optimise quantum computations. The free model may be interpreted as a programming language for quantum computers, that has the same expressivity and computational universality as the standard model, but additionally allows automated verification and reasoning.

The world relies on distributed systems, but distributed systems can be unreliable. Crashes, hangs, and data corruption happen in even the most battle-tested systems, all because some programmer didn't think "event B" would ever happen before "event A". Most distributed systems have too many event orderings to consider them all, making some bugs appear impossible to prevent---and as systems become more distributed and more of our code is written by mercurial LLMs, these bugs are becoming more of a problem. In this talk, I'll show how programming language research is giving us the tools to build faster, safer, and simpler distributed systems. We'll explore some of the elegant mathematics behind these tools and wrap up with a few fun ideas on the horizon.

The bialgebraic abstract GSOS framework by Turi and Plotkin provides an elegant categorical approach to modelling the operational and denotational semantics of programming and process languages. In abstract GSOS, bisimilarity is always a congruence, and it coincides with denotational equivalence. This saves the language designer from intricate, ad-hoc reasoning to establish these properties. The bialgebraic perspective on operational semantics in the style of abstract GSOS has recently been extended to higher-order languages, preserving compositionality of bisimilarity. However, a categorical understanding of bialgebraic denotational semantics according to Turi and Plotkin’s original vision has so far been missing in the higher-order setting. In the present paper, we develop a theory of adequate denotational semantics in higher-order abstract GSOS. The denotational models are parametric in an appropriately chosen semantic domain in the form of a locally final coalgebra for a behaviour bifunctor, whose construction is fully decoupled from the syntax of the language. Our approach captures existing accounts of denotational semantics such as semantic domains built via general step-indexing, previously introduced on a per-language basis, and is shown to be applicable to a wide range of different higher-order languages, e.g. simply typed and untyped languages, or languages with computational effects such as probabilistic or non-deterministic branching.