Klaus Ostermann's research while affiliated with University of Tuebingen and other places

Publications (111)

Preprint
Full-text available
Data types and codata types are, as the names suggest, often seen as duals of each other. However, most programming languages do not support both of them in their full generality, or if they do, they are still seen as distinct constructs with separately defined type-checking, compilation, etc. Rendel et al. were the first to propose variants of two...
Article
Functional programming language design has been shaped by the framework of natural deduction, in which language constructs are divided into introduction and elimination rules for producers of values. In sequent calculus-based languages, left introduction rules replace (right) elimination rules and provide a dedicated sublanguage for consumers of va...
Chapter
Full-text available
Regions are a useful tool for the safe and automatic management of resources. Due to their scarcity, resources are often limited in their lifetime which is associated with a certain scope. When control flow leaves the scope, the resources are released. Exceptions can non-locally exit such scopes and it is important that resources are also released...
Technical Report
Ever since the inception of Algol have programming language researchers sought good abstractions to inspect and manipulate stacks while maintaining basic invariants of program behavior. These abstractions range from procedure calls and block structure to region-based resource management and control effects. While all these abstractions are useful a...
Article
Effect handlers have recently gained popularity amongst programming language researchers. Existing type- and effect systems for effect handlers are often complicated and potentially hinder a wide-spread adoption. We present the language Effekt with the goal to close the gap between research languages with effect handlers and languages for working p...
Article
Effect handlers encourage programmers to abstract over repeated patterns of complex control flow. As of today, this abstraction comes at a significant price in performance. In this paper, we aim to achieve abstraction without regret for effect handlers. We present a language for effect handlers in _capability-passing style_ (λ Cap ) and an implemen...
Article
Full-text available
Effect handlers are a promising way to structure effectful programs in a modular way. We present the Scala library Effekt , which is centered around capability passing and implemented in terms of a monad for multi-prompt delimited continuations. Effekt is the first library implementation of effect handlers that supports effect safety and effect pol...
Article
Full-text available
The expression problem describes a fundamental trade-off in program design: Should a program's primary decomposition be determined by the way its domain objects are constructed ("functional" decomposition), or by the way they are destructed ("object-oriented" decomposition)? We argue that programming languages should not force one of these decompos...
Conference Paper
Full-text available
Academic self-concept, motivational beliefs, and attitudes towards a school subject are relevant for learning and educational achievement. A positive self-concept in science and mathematics is argued to motivate students to persist and advance in studying these subjects. In particular, self-concept, motivational beliefs, and attitudes towards STEM...
Article
Full-text available
Effect handlers are a program structuring paradigm with rising popularity in the functional programming language community and can express many advanced control flow abstractions. We present the first implementation of effect handlers for Java - an imperative, object oriented programming language. Our framework consists of three core components: A...
Conference Paper
Full-text available
Game-based approaches can be a motivating and engaging way of teaching and learning, in particular for younger students. To evaluate the suitability of game-based approaches for teaching programming in primary school, we conducted a field study on Computational Thinking (CT). CT can be characterized as the ability to understand, formulate, and syst...
Chapter
Full-text available
We characterize the relation between generalized algebraic datatypes (GADTs) with pattern matching on their constructors one hand, and generalized algebraic co-datatypes (GAcoDTs) with copattern matching on their destructors on the other hand: GADTs can be converted mechanically to GAcoDTs by refunctionalization, GAcoDTs can be converted mechanical...
Article
We present a modular semantic account of Bayesian inference algorithms for probabilistic programming lan- guages, as used in data science and machine learning. Sophisticated inference algorithms are often explained in terms of composition of smaller parts. However, neither their theoretical justification nor their implemen- tation reflects this mod...
Article
Full-text available
We present a modular semantic account of Bayesian inference algorithms for probabilistic programming languages, as used in data science and machine learning. Sophisticated inference algorithms are often explained in terms of composition of smaller parts. However, neither their theoretical justification nor their implementation reflects this modular...
Conference Paper
Brzozowski derivatives, well known in the context of regular expressions, have recently been rediscovered to give a simplified explanation to parsers of context-free languages. We add derivatives as a novel first-class feature to a standard parser combinator language. First-class derivatives enable an inversion of the control flow, allowing to impl...
Article
Brzozowski derivatives, well known in the context of regular expressions, have recently been rediscovered to give a simplified explanation to parsers of context-free languages. We add derivatives as a novel first-class feature to a standard parser combinator language. First-class derivatives enable an inversion of the control flow, allowing to impl...
Conference Paper
Traversing an algebraic datatype by hand requires boilerplate code which duplicates the structure of the datatype. Datatype-generic programming (DGP) aims to eliminate such boilerplate code by decomposing algebraic datatypes into type constructor applications from which generic traversals can be synthesized. However, different traversals require di...
Article
Traversing an algebraic datatype by hand requires boilerplate code which duplicates the structure of the datatype. Datatype-generic programming (DGP) aims to eliminate such boilerplate code by decomposing algebraic datatypes into type constructor applications from which generic traversals can be synthesized. However, different traversals require di...
Article
Defunctionalization and refunctionalization establish a correspondence between first-class functions and pattern matching, but the correspondence is not symmetric: Not all uses of pattern matching can be automatically refunctionalized to uses of higher-order functions. To remedy this asymmetry, we generalize from first-class functions to arbitrary...
Article
Oliveira and Cook (2012) and Oliveira et al. (2013) have recently introduced object algebras as a program structuring technique to improve the modularity and extensibility of programs. We analyze the relationship between object algebras and attribute grammars (AGs), a formalism to augment context-free grammars with attributes. We present an extensi...
Article
Editing the source code of variational software is complicated by the presence of variation annotations, such as #ifdef statements, and by code that is only included in some configurations. When editing some configurations and not others, it would be easier to edit a simplified version of the source code that includes only the configurations we cur...
Article
Software product line engineering is an efficient means to generate a set of tailored software products from a common implementation. However, adopting a product-line approach poses a major challenge and significant risks, since typically legacy code must be migrated toward a product line. Our aim is to lower the adoption barrier by providing semi-...
Article
Full-text available
If the result of an expensive computation is invalidated by a small change to the input, the old result should be updated incrementally instead of reexecuting the whole computation. We incrementalize programs through their derivative. A derivative maps changes in the program's input directly to changes in the program's output, without reexecuting t...
Conference Paper
Domain-specific languages (DSLs) can improve software maintainability due to less verbose syntax, avoidance of boilerplate code, more accurate static analysis, and domain-specific tool support. However, most existing applications cannot capitalise on these benefits because they were not designed to use DSLs, and rewriting large existing application...
Conference Paper
The choice calculus, a formal language for representing variation in software artifacts, features syntactic forms to map dimensions of variability to local choices between source code variants. However, the process of selecting alternatives from dimensions was relegated to an external operation. The lack of a syntactic form for selection precludes...
Conference Paper
Full-text available
The theory of context-free languages is well-understood and context-free parsers can be used as off-the-shelf tools in practice. In particular, to use a context-free parser framework, a user does not need to understand its internals but can specify a language declaratively as a grammar. However, many languages in practice are not context-free. One...
Conference Paper
Full-text available
If the result of an expensive computation is invalidated by a small change to the input, the old result should be updated incrementally instead of reexecuting the whole computation. We incrementalize programs through their derivative. A derivative maps changes in the program's input directly to changes in the program's output, without reexecuting t...
Article
Full-text available
Modularity and efficiency are often contradicting requirements, such that programers have to trade one for the other. We analyze this dilemma in the context of programs operating on collections. Performance-critical code using collections need often to be hand-optimized, leading to non-modular, brittle, and redundant code. In principle, this dilemm...
Conference Paper
Full-text available
Module systems enable a divide and conquer strategy to software development. To implement compile-time variability in software product lines, modules can be composed in different combinations. However, this way, variability dictates a dominant decomposition. As an alternative, we introduce a variability-aware module system that supports compile-tim...
Conference Paper
Conventional collection libraries do not perform automatic collection-specific optimizations. Instead, performance-critical code using collections must be hand-optimized, leading to non-modular, brittle, and redundant code. We propose SQuOpt, the Scala Query Optimizer, a deep embedding of the Scala collection library performing collection-specific...
Article
Full-text available
Programmers need convenient syntax to write elegant and concise programs. Consequently, the Haskell standard provides syntactic sugar for some scenarios (e.g., do notation for monadic code), authors of Haskell compilers provide syntactic sugar for more scenarios (e.g., arrow notation in GHC), and some Haskell programmers implement preprocessors for...
Article
Large software projects consist of code written in a multitude of different (possibly domain-specific) languages, which are often deeply interspersed even in single files. While many proposals exist on how to integrate languages semantically and syntactically, the question of how to support this scenario in integrated development environments (IDEs...
Article
Object-oriented languages come with pre-defined composition mechanisms, such as inheritance, object composition, or delegation, each characterized by a certain set of composition properties, which do not themselves individually exist as abstractions at the language level. However, often non-standard composition semantics is needed, with a mixture o...
Conference Paper
Full-text available
SugarJ is a Java-based programming language that provides extensible surface syntax, static analyses, and IDE support. SugarJ extensions are organized as libraries; conventional import statements suffice to activate and compose language extensions. We demonstrate how programmers can use SugarJ to modularly extend Java's syntax, semantic analyses an...
Conference Paper
Full-text available
SugarJ is a Java-based programming language that provides extensible surface syntax, static analyses, and IDE support. SugarJ extensions are organized as libraries; conventional import statements suffice to activate and compose language extensions. We illustrate how programmers can use SugarJ to modularly extend Java's syntax, semantic analyses and...
Conference Paper
Existing approaches to extend a programming language with syntactic sugar often leave a bitter taste, because they cannot be used with the same ease as the main extension mechanism of the programming language - libraries. Sugar libraries are a novel approach for syntactically extending a programming language within the language. A sugar library is...
Conference Paper
Full-text available
In many projects, lexical preprocessors are used to manage different variants of the project (using conditional compilation) and to define compile-time code transformations (using macros). Unfortunately, while being a simply way to implement variability, conditional compilation and lexical macros hinder automatic analysis, even though such analysis...
Conference Paper
Full-text available
Large software projects consist of code written in a multitude of different (possibly domain-specific) languages, which are often deeply interspersed even in single files. While many proposals exist on how to integrate languages semantically and syntactically, the question of how to support this scenario in integrated development environments (IDEs...
Conference Paper
Full-text available
Existing approaches to extend a programming language with syntactic sugar often leave a bitter taste, because they cannot be used with the same ease as the main extension mechanism of the programming language---libraries. Sugar libraries are a novel approach for syntactically extending a programming language within the language. A sugar library is...
Article
Software product line engineering is an efficient means to generate a set of tailored software products from a common implementation. However, adopting a product-line approach poses a major challenge and significant risks, since typically legacy code must be migrated toward a product line. Our aim is to lower the adoption barrier by providing semia...
Conference Paper
Modularity of feature representations has been a long standing goal of feature-oriented software development. While some researchers regard feature modules and corresponding composition mechanisms as a modular solution, other researchers have challenged the notion of feature modularity and pointed out that most feature-oriented implementation mecha...
Conference Paper
Full-text available
What is modularity? Which kind of modularity should developers strive for? Despite decades of research on modularity, these basic questions have no definite answer. We submit that the common understanding of modularity, and in particular its notion of information hiding, is deeply rooted in classical logic. We analyze how classical modularity, base...
Conference Paper
Full-text available
The C preprocessor is commonly used to implement variability. Given a feature selection, code fragments can be excluded from compilation with #ifdef and similar directives. However, the token-based nature of the C preprocessor makes variability implementation difficult and errorprone. Additionally, variability mechanisms are intertwined with macro...
Article
Parsers and pretty-printers for a language are often quite similar, yet both are typically implemented separately, leading to redundancy and potential inconsistency. We propose a new interface of syntactic descriptions, with which both parser and pretty-printer can be described as a single program. Whether a syntactic description is used as a parse...
Conference Paper
Dynamic aspect-oriented programming has been widely used for the development of dynamic analyses to abstract over low-level program instrumentation. Due to particular feature requirements in different analysis domains like debugging or testing, many different aspect languages were developed from scratch or by extensive compiler or interpreter exten...
Conference Paper
In logic metaprogramming, programs are not stored as plain textfiles but rather derived from a deductive database. While the benefits of this approach for metaprogramming are obvious, its incompatibility with separate checking limits its applicability to large-scale projects. We analyze the problems inhibiting separate checking and propose a class...
Conference Paper
Full-text available
TeX (and its LaTeX incarnation) is a widely used document preparation system for technical and scientific documents. At the same time, TeX is also an unusual programming language with a quite powerful macro system. Despite the wide range of TeX users (especially in the scientific community), and despite a widely perceived considerable level of “pai...
Conference Paper
Programs in domain-­specific embedded languages (DSELs) can be represented in the host language in different ways, for instance implicitly as libraries, or explicitly in the form of abstract syntax trees. Each of these representations has its own strengths and weaknesses. The implicit approach has good composability properties, whereas the explicit...
Conference Paper
Parsers and pretty-printers for a language are often quite similar, yet both are typically implemented separately, leading to redundancy and potential inconsistency. We propose a new interface of syntactic descriptions, with which both parser and pretty-printer can be described as a single program. Whether a syntactic description is used as a parse...
Article
The implementation of unit tests with mock objects and stubs often involves substantial manual work. Stubbed methods return simple default values, therefore variations of these values require separate test cases. The integration of mock objects often requires more infrastructure code and design decisions exposing private data. We present an approac...
Conference Paper
Abstractions are used in model checking to tackle problems like state space explosion or modeling of IO. The application of these abstractions in real software development processes, however, lacks engineering support. This is one reason why model checking is not widely used in practice yet and testing is still state of the art in falsification. We...
Conference Paper
In runtime monitoring and aspect-oriented programming, the execution of a program is monitored to check whether a property { formulated in a pointcut language { holds at some point in the execution of the program. Pointcut languages dier signicantly in their expres- siveness and the amount of information they utilize about the state of the program'...
Conference Paper
Self-representation -- the ability to represent programs in their own language -- has important applications in reflective languages and many other domains of programming language design. Although approaches to designing typed program representations for sublanguages of some base language have become quite popular recently, the question whether a f...
Conference Paper
Theinfluential pure embedding methodology of embedding domain- specific languages (DSLs) as libraries into a general-purpose host language forces the DSL designer to commit to a single semantics. This precludes the subsequent addition of compilation, optimiza- tion or domain-specific analyses. We propose polymorphic embed- ding of DSLs, where many...
Article
In nominal type systems, the subtype relation is between names of types, and subtype links are explicitly declared. In structural type systems, names are irrelevant; in deter- mining type compatibility, only the structure of types is considered, and a type name is just an abbreviation for the full type. We analyze structural and dierent avors of no...
Conference Paper
There has been a lot of debate about the modularity of aspect- oriented programs, and in particular the ability to reason about such programs in a modular way, although it has never been defined pre- cisely what modular reasoning means. This work analyzes what it means to reason about a program, and separates "modular reason- ing" into several well...
Conference Paper
To use a framework, developers need to understand its building blocks. In this paper, we present a clustering technique that employs usage data from framework instantiations as examples to produce an overview of a framework's main building blocks as seen from a user's perspective. The evaluation of the approach by two case studies shows that the au...
Article
Virtual classes allow nested classes to be refined in subclasses. In this way nested classes can be seen as dependent abstractions of the objects of the enclosing classes. Expressing dependency via nesting, however, has two limitations: Abstractions that depend on more than one object cannot be modeled and a class must know all classes that depend...
Conference Paper
Virtual classes allow nested classes to be refined in subclasses. In this way nested classes can be seen as dependent abstractions of the objects of the enclosing classes. Expressing dependency via nesting, however, has two limitations: Abstractions that depend on more than one object cannot be modeled and a class must know all classes that depend...
Conference Paper
Nonmonotonic logic is a branch of logic that has been de- veloped to model situations with incomplete information. We argue that there is a connection between AOP and non- monotonic logic which deserves further study. As a con- crete technical contribution and "appetizer", we outline an AO semantics defined in default logic (a form of nonmono- toni...
Conference Paper
The relation between aspects and monads is a recurring topic in discussions in the programming language commu- nity, although it has never been elaborated whether their resemblences are only superficial, and if not, where they are rooted. The aim of this paper is to contrast both mech- anisms w.r.t. their capabilities and their eects on modu- larit...
Conference Paper
Modern development environments integrate various static analyses into the build process. Analyses that analyze the whole project whenever the project changes are impractical in this context. We present an approach to au- tomatic incrementalization of analyses that are specified as tabled logic programs and evaluated using incremental tabled evalua...
Conference Paper
In aspect-oriented programming, pointcuts are usually compiled by identifying a set of shadows — that is, places in the code whose execution is potentially relevant for a pointcut — and inserting dynamic checks at these places for those parts of the pointcut that cannot be evaluated statically. Today, the algorithms for shadow and check computation...
Article
Modern development environments integrate various static analyses into the build process. But, analyses that analyze the whole project whenever the project changes are impractical in this context. We present an approach to automatic incre-mentalization of analyses that are specified as tabled logic programs and evaluated using incremental tabled ev...
Conference Paper
The abilities to extend a software module and to integrate a soft- ware module into an existing software system without changing existing source code are fundamental challenges in software en- gineering and programming-language design. We reconsider these challenges at the level of language expressiveness, by using the lan- guage concept of type cl...
Conference Paper
Full-text available
Virtual classes are class-valued attributes of objects. Like virtual methods, virtual classes are defined in an object’s class and may be redefined within subclasses. They resemble inner classes, which are also defined within a class, but virtual classes are accessed through object instances, not as static components of a class. When used as types,...
Conference Paper
CaesarJ is an aspect-oriented language which unifies aspects, classes and packages in a single powerful construct that helps to solve a set of different problems of both aspect-oriented and component-oriented programming. The paper gradually introducesthe concepts of the language and illustrates them by showing how they can be used for noninvasive...
Article
To improve the productivity of the development process, more and more tools for static software analysis are tightly integrated into the incremental build process of an IDE. If multiple interdependent analyses are used simultaneously, the coordination between the analyses becomes a major obstacle to keep the set of analyses open. We propose an appr...
Conference Paper
In aspect-oriented programming, pointcuts are used to describe crosscutting structure. Pointcuts that abstract over irrelevant implementation details are clearly desired to better support maintainability and modular reasoning. We present an analysis which shows that current pointcut languages support localization of crosscutting concerns but are pr...
Article
Pointcuts in aspect-oriented languages can be seen as pred- icates over events in the computation of a program. The ability to express temporal relations between such events is a key feature towards more expressive pointcut languages. In this paper, we describe the design and implementation of a pointcut language within which pointcuts are predicat...
Conference Paper
We describe XIRC, a tool and architecture that enables to define queries over a uniform representation of all artifacts of a software project. These queries can be used for general cross-artifact information retrieval or for more special applications like checking implementation restrictions or conformance to style guides. XIRC is also a good basis...
Article
This paper presents an analysis of feature-oriented and aspect-oriented modularization approaches with respect to variability management as needed in the context of system families. This analysis serves two purposes. On the one hand, our analysis of the weaknesses of feature-oriented approaches (FOAs for short) emphasizes the importance of crosscut...
Conference Paper
Traditional programming languages assume that real-world systems have “intuitive”, mind-independent, preexisting concept hierarchies. However, our perception of the world depends heavily on the context from which it is viewed: Every software system can be viewed from multiple different perspectives, and each of these perspectives may imply a differ...
Article
Full-text available
We suggest a simple model for a restricted form of dependent types in object oriented languages, whereby classes belong to groups and dependency is introduced via intragroup references using the MyGrp keyword. We introduce motivating and exploratory examples, present the formal model and outline soundness of the type system.
Article
Full-text available
A widespread implementation approach for the join point mechanism of aspect-oriented languages is to instrument areas in code that match the static part of pointcut designators, inserting dynamic checks for that part of matching that depends on run-time conditions, if needed. For performance reasons, such dynamic checks should be avoided whenever p...
Conference Paper
Most aspect-oriented languages provide only a fixed, built-in set of pointcut designators whose denotation is only described informally. As a consequence, these languages do not provide operations to manipulate or reason about pointcuts beyond weaving. In this paper, we investigate the usage of the functional query language XQuery for the specifica...
Conference Paper
Program generation and transformation techniques have gained considerable attention in the context of domain-specific languages (DSLs) and model-driven architecture (MDA). In this paper we compare domain-specific program generators with general-purpose aspect-oriented languages. We argue that program generation techniques have severe disadvantages...
Article
SUMMARY Server-side component models such as Enterprise JavaBeans (EJB) add powerful abstractions to the bare "business objects" layer in order to support a clean separation of server-side application logic from other concerns such as distribution, security, transaction management and persistence. An improved separation of concerns is also the main...
Article
Join point interception (JPI), is considered an important cornerstone of aspect-oriented languages. However, we claim that JPI alone does not suffice for a modular structuring of aspects. We propose Caesar, a model for aspect-oriented programming with a higher-level module concept on top of JPI, which enables reuse and componentization of aspects,...
Article
This paper proposes language concepts that facilitate the separation of an application into independent reusable building blocks and the integration of pre-build generic software components into applications that have been developed by third party vendors. A key element of our approach are on-demand remodularizations, meaning that the abstractions...
Conference Paper
It has been recognized in several works that a slice of behavior affecting a set of collaborating classes is a better unit of reuse than a single class. Different techniques and language extensions have been suggested to express such slices in programming languages. We propose delegation layers, an approach that scales the OO mechanisms for single...
Article
Object-oriented languages come with pre-defined composition mechanisms, such as inheritance, object composition, or delegation, each characterized by a certain set of composition properties, which do not themselves individually exist as abstractions at the language level. However, often non-standard composition semantics is needed, with a mixture o...
Article
It has been recognized in several works that a slice of behavior affecting a set of collaborating classes is a better unit of reuse than a single class. Different techniques and language extensions have been proposed to express such slices in programming languages. We present a Java language extension that builds up on mixin layers and combines and...
Article
Full-text available
In this paper we consider two important trends in improving separation of concerns: (a) the emergence of server-side component frameworks, and (b) the emergence of advanced approaches to software decomposition/composition. These two trends have emerged independently from each other, the first one in an industrial setting and the second one originat...
Article
In this paper we consider two important trends in improving separation of concerns: (a) the emergence of server-side component frameworks, and (b) the emergence of advanced approaches to software decomposition /composition. These two trends have emerged independently from each other, the first one in an industrial setting and the second one origina...
Article
Object-oriented languages come with pre-defined composition mechanisms, such as inheritance, object composition, or delegation, each characterized by a certain set of composition properties, which do not themselves individually exist as abstractions at the language level. However, often non-standard composition semantics is needed, with a mixture o...
Article
Component-based applications require more than simply components. They extend and configure components and "glue" them together to construct an application. Requirements like extensibility and configurability become mission critical. Traditional solutions in this area rely on software design patterns and have been successfully employed for a large...
Article
AspectJ and Hyper/J provide di#erent ways to modify classes that are used by existing clients. We think that a significant share of their di#erences can be attributed to the use of complementary ways to implement changes and to propagate them to clients: AspectJ uses in-place modification whereas Hyper/J uses client migration. Whereas these techniq...
Article
Interactive grouping and filtering in software visualiza-tion tools are essential mechanisms enabling the users to build views that match the information needs of their soft-ware comprehension task at hand. In this paper we sys-tematically survey these mechanisms in eight graph-based software visualization tools.
Article
Modularization of software is driven by the principle of sep-aration of concerns, which often does not correspond to the direction of calls between modules. Therefore observation techniques play important role for avoiding cyclic dependen-cies between modules. Object-oriented observation mecha-nisms require too much design and implementation effort...
Article
This paper investigates the usage of aspect-oriented techniques to increase the modularity and reusability of algorithms. We present a set of criteria to evaluate the modularity and reusability of algorithm implementations and argue that current algorithm libraries have serious limitations with respect to these criteria. We have implemented a small...

Citations

... Lexically scoped handlers. The characteristic intended feature of a "lexically scoped handler " is the fact that one can statically tell which handler is invoked when an effect is performed [SBMO22]. This can be achieved by installing a handler for a freshly generated effect label, that is, a label generated immediately before the handler is installed. ...
... We make the target context parametric in the flag, preventing calls to any of the actions of the underlying Dijkstra Monad-as the flag could take the value NoActions-and we refer to this form of effect polymorphism as flag-based effect polymorphism. This was inspired from work on effect polymorphism where each action is treated as a separate effect [10,42], however we do not need that fine level of granularity. Because the target context is parametric in the flag it cannot call the default IO operations, and instead to perform any IO it has to call our secure IO operations, which we pass to it as argument. ...
... For instance, staging is a widely studied area [19,25,22]. Some works have also combined algebraic effects with staging mechanisms [31, 21,28]. Yet, we are, to the best of our knowledge, the first to consider staging using effect handlers. ...
... The "Self-Concept and Attitude toward Programming Assessment" (SCAPA) by Leifheit et al. [70,71] is a seven scale questionnaire, focusing on self-reported prior experience and understanding of programming, self-concept with regard to programming, intrinsic value belief about programming, attainment value belief about programming, utility value belief about programming, cost belief about programming and compliance and persistence with regard to programming. The target group of the questionnaire are primary school children, so the authors placed particular emphasis on simple and understandable language during creation. ...
... They do not further address the problem of IDE reuse for domain experts. Quite a similar approach is proposed by Erdweg et al. [48], who basically focus on native support for embedding directly at the IDE level. They propose to organize editor features into editor libraries that should provide a simple way to extend the IDE to support the embedded language. ...
... Moreover, effect handlers can simulate most delimited-control operators [FKLP19]. For these reasons, effect handlers are finding their way into research programming languages such as Eff [BP15,BP20], Effekt [BSO20b,BSO20a], Frank [LMM17], Koka [Lei14,Lei20], Links [HLA20], and into mainstream programming languages such as OCaml 5 [SDW + 21]. ...
... It refers to a logical approach towards solving problems through problem formulation, data organisation, analysis and representation (Denning & Tedre, 2019;Voskoglou & Buckley, 2012). CT is a process of thinking in which problems and their solutions can be reformulated to allow them to be presented in a form that can be effectively implemented by an information processing digital agent (Dummer, 2017;Leifheit et al., 2018;Vourletsis & Politis, 2021). Skills such as problem decomposition, algorithmic thinking, pattern recognition, parallelisation and abstraction are addressed (Catlin & Woollard, 2014;Chalmers, 2018;SLO, 2017). ...