In graph grammars based on borrowing hyperedge replacement (BHR), a production replaces a hyperedge by a hypergraph that contains borrowed nodes, which are later contracted with other nodes of the graph being derived. In contrast to context-free hyperedge replacement, this allows graph languages of unbounded treewidth to be defined. Here we further equip the productions of BHR grammars with conditions, which are specified by graph formulas that may require (or forbid) the existence of paths of arbitrary length in the graphs of the language. This is defined in such a way that the top-down parsers for BHR grammars devised in earlier work can be extended to verify these conditions.

A recent paper by Drewes, Hoffmann, and Minas (GCM 2023 proceedings) has shown that certain graph languages can be defined and efficiently recognized by finite automata when strings over typed symbols are interpreted as graphs. This approach has been implemented in the tool GrappaRE, which is described in this paper. GrappaRE allows for the convenient specification of graph languages through regular expressions, converts each of them into a minimized deterministic finite automaton, and checks whether it can recognize graphs without the need for backtracking. Measurements confirm that recognition runs in linear time.

Graph-based modeling plays a fundamental role in many areas of computer science. In this paper, we introduce systems of graph formulas with variables for specifying graph properties; this notion generalizes the graph formulas introduced in earlier work by incorporating recursion. We show that these formula systems have the same expressive power as alternating graph automata, a computational model that extends traditional finite-state automata to graphs, and allows both existential and universal states. In particular, we provide a bidirectional translation between formula systems and alternating graph automata, proving their equivalence in specifying graph languages. This result implies that alternating graph automata can be naturally represented using logic-based formulations, thus bridging the gap between automata-theoretic and logic-based approaches to graph language specification.

Computer science and related courses of study require a sound education in software engineering. We have designed and continuously developed a software engineering project course to serve these topics. The COVID-19 pandemic was a turning point in many ways, including for our course and the way we taught during and after that time. We describe how we adapted the course to these new pandemic conditions. In particular, we introduced an automated program assessment system that helped us keep the difficulty of all assignments constant, even during hybrid and online-only classes for the different student teams, while keeping the motivation of individual students in each team high. We started with a binary (pass/fail) grading system, but we saw that a fine-grained individual grading is worth investigating and might lead to higher acceptance and willingness to participate among students. Both automatic assessment and individual grading, and increasingly code generation, are a case for AI. We use the state of the art to show where AI can be applied to our specific programming tasks and where its limitations lie.

Graphs are widely used in various domains to model complex relationships, often requiring the specification and verification of their properties. These properties may involve complex conditions placing, e.g., structural requirements on subgraphs of unbounded size. In this paper, we propose graph formulas as a new formalism for specifying graph properties, providing a higher level of "graphical" abstraction compared to well-known approaches such as monadic second-order logic. We show how these graph formulas can be translated into alternating graph automata, allowing to check computationally difficult graph properties, such as the existence or non-existence of Hamiltonian paths.

The rapid emergence of generative AI tools is transforming software development. Consequently, software engineering education must adapt to ensure that students not only learn traditional development methods but also understand how to use these new technologies effectively and responsibly. In particular, project-based courses provide an effective setting in which to explore and evaluate the integration of AI assistance into real-world development practices. This paper presents our approach and a user study conducted in the context of a university programming project in which students collaboratively developed computer games. The study investigates how participants used generative AI tools across different phases of the software development process, identifies the tasks for which these tools were perceived as most useful, and analyzes the challenges students encountered. Building on these insights, we further examine a repository-aware, locally deployed large language model (LLM) assistant designed to provide project-contextualized support. The system employs retrieval-augmented generation (RAG) to ground its responses in relevant documentation and source code, thereby enabling a qualitative analysis of model behavior, parameter sensitivity, and common failure modes. These findings deepen our understanding of context-aware AI support in educational software projects and inform the future integration of AI-based assistance into software engineering curricula.

The way software is developed is changing rapidly due to the general availability of generative AI tools. As a result, the software engineering education that is part of every computer science program needs to change. Especially in software engineering courses, such AI tools need to be used and practiced in a meaningful and useful way. The programming project is one such course at our university, and the curriculum will be expanded accordingly in the future. In this paper we describe our approach and a user study among the participants of the last programming project, in which we collected experiences with the use of current AI tools, in particular highlighting their usefulness and limitations. Our study focuses on identifying which aspects of the course students used AI tools for, evaluating successful applications, and uncovering remaining challenges.

Engelfriet and Vereijken have shown that linear graph grammars based on hyperedge replacement generate graph languages that can be considered as interpretations of regular string languages over typed symbols. In this paper we show that finite automata can be lifted from strings to graphs within the same framework. For the efficient recognition of graphs with these automata, we make them deterministic by a modified powerset construction, and state sufficient conditions under which deterministic finite graph automata recognize graphs without the need to use backtracking.

In many application areas, it is necessary to specify and check properties of graphs. Such properties may be complex, placing structural requirements on graph regions of unbounded size. In this paper, we show that alternating graph automata can check such graph properties, e.g., whether a given input graph is a tree, or whether it contains a Hamiltonian cycle or not. In fact, we show that these automata can accept PSPACE-complete graph languages, and that their uniform membership problem is contained in PSPACE when only automata without permutation cycles are considered.

Frequent student complaints about the complexity of traditional debuggers and the lack of visualization for key data structures motivated us to develop BugVis, a debugger designed for ease of use and customizability. BugVis allows users to focus on essential data structures and visualize them in a blackboard-like manner. In addition to standard debugging features, it supports both customizable visualizations and time-travel debugging, enabling users to navigate through execution history for deeper program analysis.

Education in software engineering is a must in all computer science courses. At the Institute for Software Technology, we are responsible for all teaching in this area. For many years we have developed and continuously refined a software development project course to serve these topics. The COVID-19 pandemic had a particular impact on our project course and the way we taught during that time. We describe how we adapted the course to these new conditions. In particular, we used an automated program assessment system that helped us keep the difficulty of all assignments constant for the different student teams while maintaining the motivation of the individual students on each team. In this paper, we demonstrate that our approach was robust even in an emergency remote teaching (ERT) environment, is based on a continuous improvement process, feedback evaluation, and process adaptation, and will continue at an improved level in the post-corona era. Students report that the course had been fun.

Graph grammars based on contextual hyperedge replacement (CHR) extend the generative power of the well-known hyperedge replacement (HR) grammars to an extent that makes them useful for practical modeling. Recent work has shown that acyclicity is a key condition for parsing CHR grammars efficiently. In this paper we show that acyclicity of CHR grammars is decidable and that the generative power of acyclic CHR grammars lies strictly between that of HR grammars and unrestricted CHR grammars.

Contextual hyperedge replacement (CHR) strengthens the generative power of hyperedge replacement (HR) significantly, thus increasing its usefulness for practical modeling. We define top-down parsing for CHR grammars by graph transformation, and prove that it is correct as long as the generation and use of context nodes in productions does not create cyclic dependencies. An efficient predictive version of this algorithm can be obtained as in the case of HR grammars.

In this paper, we present ParVis , an interactive visual system for the animated visualization of logged parser trace executions. The system allows a parser implementer to create a visualizer for generated parsers by simply defining a JavaScript module that maps each logged parser instruction into a set of events driving the visual system interface. The result is a set of interacting graphical/text windows that allows users to explore logged parser executions and helps them to have a complete understanding of how the parser behaves during its execution on a given input. We used our system to visualize the behavior of textual as well as visual parsers and describe here two of these uses. Moreover, in order to validate the efficacy of our system, we ran a user experiment where students analyzed a CUP-generated parser both with ParVis , instantiated to LALR parsers, and the standard CUP debug facilities. The results show that students can indeed analyze parser behavior and find mistakes in parser specifications more easily and quickly using ParVis . In particular, in some parser design tasks, using ParVis participants achieved a higher success rate of 50 % in 42 % less time with respect to the baseline system.

Hyperedge replacement (HR) allows to define context-free graph languages, but parsing is NP-hard in the general case. Predictive top-down (PTD) is an efficient, backtrack-free parsing algorithm for subclasses of HR and contextual HR grammars, which has been described and implemented in earlier work, based on a representation of graphs and grammar productions as strings. In this paper, we define PTD parsers for HR grammars by graph transformation rules and prove that they are correct.

In this paper, we present ParVis, an interactive visual system for the animated visualization of logged parser trace executions. The system allows a parser implementer to create a visualizer for generated parsers by simply defining a JavaScript module that maps each logged parser instruction into a set of events driving the visual system interface. The result is a set of interacting graphical/text windows that allows users to explore logged parser executions and helps them to have a complete understanding of how the parser behaves during its execution on a given input.

Parsing of visual structures like diagrams and graphs is more complicated than parsing strings.This is so because visual structures are inherently more complex than strings, because visual grammars are more difficult to write than string grammars, and because the algorithms for parsing visual structures are usually more complicated than for parsing strings.The developer of a visual parser, therefore, needs more tool support than a developer of a string parser.In fact, developing and debugging a visual parser without proper visualization of the parsing process is very challenging.This paper describes a visualization approach that arose from this need.Its main focus is on the interaction of the developer with the visualization tool in order to explore the execution process of the parser.It has evolved from experiences with developing and debugging parsers by applying different visual parsing methods.In order to better describe it we introduce a concrete example.

In this paper, we present PARVIS, an interactive visual system for the animated visualization of logged parser trace executions. The system allows a parser implementer to create a visualizer for generated parsers by simply defining a JavaScript module that maps each logged parser instruction into a set of events driving the visual system interface. The result is a set of interacting graphical/text windows that allows users to explore logged parser executions and helps them to have a complete understanding of how the parser behaves during its execution on a given input. We used our system to visualize the behavior of textual as well as visual parsers and describe here its use with the well known CUP parser generator. Preliminary tests with users have provided good feedback on its use.

Hyperedge replacement (HR) grammars can generate NP-complete graph languages, which makes parsing hard even for fixed HR languages. Therefore, we study predictive shift-reduce (PSR) parsing that yields efficient parsers for a subclass of HR grammars, by generalizing the concepts of SLR(1) string parsing to graphs. We formalize the construction of PSR parsers and show that it is correct. PSR parsers run in linear space and time, and are more efficient than the predictive top-down (PTD) parsers recently developed by the authors.