# 2022 ## Introduction to RelationalAI and how we use Julia Presented at JuliaCon, July 2022. [![[youtube.png|100]]](https://www.youtube.com/watch?v=Pncp0puIwI0) ## Design and Implementation of the RelationalAI System Presented at University of Washington seminar on Advanced Topics in Data Management, June 2022. [![[pdf-logo.png|50]]](https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/RelationalAI_UW_2022-05-26.pdf) ## Languages and Algorithms for Relational Knowledge Graphs Presented at the Dutch Seminar on Data Systems Designs, May 2022. [![[youtube.png|100]]](https://www.youtube.com/watch?v=KUf7xG3zGrI) RelationalAI is the next-generation database system for new intelligent data applications based on relational knowledge graphs. RelationalAI complements the modern data stack by allowing data applications to be implemented relationally and declaratively, leveraging knowledge/semantics for reasoning, graph analytics, relational machine learning, and mathematical optimization workloads. RelationalAI as a relational and cloud native system fits naturally in the modern data stack, providing virtually infinite compute and storage capacity, versioning, and a fully managed system. RelationalAI supports the workload of data applications with an expressive relational language (called Rel), novel join algorithms and JIT compilation suitable for complex computational workloads, semantic optimization that leverages knowledge to optimize application logic, and incrementality of the entire system for both data (IVM) and code (live programming). The system utilizes immutable data structures, versioning, parallelism, distribution, out-of-core memory management to support state-of-the-art workload isolation and scalability for simple as well as complex business logic. In our experience, RelationalAI’s expressive, relational, and declarative language leads to a 10-100x reduction in code for complex business domains. Applications are developed faster, with superior quality by bringing non-technical domain experts into the process and by automating away complex programming tasks. We discuss the core innovations that underpin the RelationalAI system: an expressive relational language, worst-case optimal join algorithms, semantic optimization, just-in-time compilation, schema discovery and evolution, incrementality and immutability. ## Building Data Apps with RelationalAI Presented at the Northwest Database Society, May 2022. [![[pdf-logo.png|50]]](https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/nwds-2022.pdf) ## Design and Implementation of the RelationalAI System Presented at CMU Database Tech Talks. [![[youtube.png|100]]](https://www.youtube.com/watch?v=WRHy7M30mM4) RelationalAI is the next-generation database platform for new intelligent data applications based on relational knowledge graphs. The Relational Knowledge Graph Management System (KGMS) complements the modern data stack by allowing data applications to be implemented relationally and declaratively, leveraging knowledge/semantics for reasoning, graph analytics, relational machine learning, and mathematical optimization workloads. RelationalAI as a relational and cloud native system fits naturally in the modern data stack, providing virtually infinite compute and storage capacity, versioning, and a fully managed system. RelationalAI supports the workload of data applications with an expressive relational language (called Rel), novel join algorithms and JIT compilation suitable for complex computational workloads, semantic optimization that leverages knowledge to optimize application logic, and incrementality of the entire system for both data (IVM) and code (live programming). The system utilizes immutable data structures, versioning, parallelism, distribution, out-of-core memory management to support state-of-the-art workload isolation and scalability for simple as well as complex business logic. In our experience, RelationalAI’s expressive, relational, and declarative language leads to a 10-100x reduction in code for complex business domains. Applications are developed faster, with superior quality by bringing non-technical domain experts into the process and by automating away complex programming tasks. We discuss the core innovations that underpin the RelationalAI system: an expressive relational language, worst-case optimal join algorithms, semantic optimization, just-in-time compilation, schema discovery and evolution, incrementality and immutability. # 2020 ## Salsa.jl: A Framework for On-demand, Incremental Computation Presented at JuliaCon 2020 [![[youtube.png|100]]](https://www.youtube.com/watch?v=0uzrH2Ee494) Note: the presentation is by my colleague Nathan Daly. I contributed to the architectural introduction of Salsa in the [[RelationalAI]] system. It is based on the outstanding talk [Responsive Compilers](https://www.youtube.com/watch?v=N6b44kMS6OM) by Nicholas Matsakis at PLISS 2019. Salsa.jl is a framework for on-demand, incremental computation. This type of incremental computing is seen in modern compilers (for IDEs), database systems (to maintain queries), spreadsheets (to recompute values on edits) and web applications (for UIs). Salsa guides and simplifies writing such applications and ensures correctness by construction. We use Salsa at RelationalAI as the core of our highly responsive compiler and database product. Incremental computation reframes the way we build responsive systems such as databases, compilers, ML applications, spreadsheets, and web apps. Performing the minimal amount of computation needed to update a result means avoiding re-running a full computation, boosting performance. Modern compilers are one such challenging responsive system. Programmers expect tools (Atom, VSCode) to understand their programs while typing, and to provide syntax highlighting, cross-linking, error indicators, auto-completion and documentation. IDEs essentially need a full-blown compiler front-end. To facilitate this, modern compilers are no longer designed as batch compilers consisting of distinct passes, but rather with on-demand usage as a primary use case (eg by allowing cheaply type-checking a function while accepting errors). To meet this challenge, state-of-the-art compilers employ generic frameworks for incremental computing. Rust uses the salsa framework (see this PLISS 2019 recording for an in-depth discussion). In this talk, we introduce Salsa.jl, which is inspired by Rust's salsa. Salsa.jl (like incremental computing frameworks in general) takes away the guesswork in building efficient incremental systems through its automatic dependency tracking and cache invalidation via versioning. Salsa.jl also introduces novel incremental computation features such as maintaining computations, recursion, and improved dependency analysis. For example, thanks to Julia, Salsa is extensible and supports using existing automatic differentiation tools to maintain computations. We use Salsa in production to build a declarative programming language and database system with fast incremental evaluation and immediate feedback. As a novel use-case, we show how Salsa makes it easy to implement a multi-stage language where compilation and evaluation are interleaved. We show how to use Salsa to build a small on-demand compiler and an incremental spreadsheet that is correct by construction. Salsa takes advantage of Julia's meta-programming features and design choices, such as macros, dynamic computation, multiple dispatch, excellent performance, and bias towards immutable data structures. This talk demonstrates that Julia is a remarkably pleasant and productive language for implementing compilers and for incremental computation more broadly. # 2018 ## Delve Language Design Proposal Presented at RelationalAI, January 2018 This presentation was the initial design proposal for what is now called the Rel language (at the time the codename was Delve). Notably, I introduced the ideas around aggregation syntax, correlated sub-queries, higher-order capabilities, vectors of variables (varargs) and partial/staged evaluation. # 2011 ## Using Datalog for Fast and Easy Program Analysis Presented at the Datalog 2.0 Workshop, 2011 Our recent work introduced the Doop framework for points-to analysis of Java programs. Although Datalog has been used for points-to analyses before, Doop is the first implementation to express full end-to-end context-sensitive analyses in Datalog. This includes key elements such as call-graph construction as well as the logic dealing with various semantic complexities of the Java language (native methods, reflection, threading, etc.). The findings from the Doop research effort have been surprising. We set out to create a framework that would be highly complete and elegant without sacrificing performance “too much”. By the time Doop reached maturity, it was a full order-of-magnitude faster than Lhotak and Hendren’s Paddle—the state-of-theart framework for context-sensitive points-to analyses. For the exact same logical points-to definitions (and, consequently, identical precision) Doop is more than 15x faster than Paddle for a 1-call-site sensitive analysis, with lower but still substantial speedups for other important analyses. Additionally, Doop scales to very precise analyses that are impossible with prior frameworks, directly addressing open problems in past literature. Finally, our implementation is modular and can be easily configured to analyses with a wide range of characteristics, largely due to its declarativeness. Although this performance difference is largely attributable to architectural choices (e.g., the use of an explicit representation vs. BDDs), we believe that our ability to efficiently optimize our implementation was largely due to the declarative specifications of analyses. Working at the Datalog level eliminated much of the artificial complexity of a points-to analysis implementation, allowing us to concentrate on indexing optimizations and on the algorithmic essence of each analysis. # 2009 ## Exception Analysis and Points-to Analysis: Better Together <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/issta09-slides.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td> <td valign="top"> Presented at International Symposium on Software Testing and Analysis (ISSTA 2009), July 2009. </td></tr></table> Exception analysis and points-to analysis are typically done in complete separation. Past algorithms for precise exception analysis (e.g., pairing throw clauses with catch statements) use pre-computed points-to information. Past points-to analyses either unsoundly ignore exceptions, or conservatively compute a crude approximation of exception throwing (e.g., considering an exception throw as an assignment to a global variable, accessible from any catch clause). We show that this separation results in significant slowdowns or vast imprecision. The two kinds of analyses are interdependent: neither can be performed accurately without the other. The interdependency leads us to propose a joint handling for performance and precision. We show that our exception analysis is expressible highly elegantly in a declarative form, and can apply to points-to analyses of varying precision. In fact, our specification of exception analysis is ``fully precise'', as it models closely the Java exception handling semantics. The necessary approximation is provided only through whichever abstractions are used for contexts and objects in the base points-to analysis. Our combined approach achieves similar precision relative to exceptions (exception-catch links) as the best past precise exception analysis, with a runtime of seconds instead of tens of minutes. At the same time, our analysis achieves much higher precision of points-to information (an average of half as many values for each reachable variable for most of the DaCapo benchmarks) than points-to analyses that treat exceptions conservatively, all at a fraction of the execution time. ## Software Development Challenges: Abstraction and Analysis <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/waterloo09.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Presented at University of Waterloo, Canada, April 2, 2009 </td></tr></table> In modern software development the use of multiple software languages to constitute a single application is ubiquitous. Despite the omnipresent use of combinations of languages, the methods of using languages together are ad-hoc, unfriendly to programmers, and result in a poor level of integration. We present examples of problematic integration, such as security vulnerabilities, and show how a principled and generic solution to language extensibility solves these problems. The parsing techniques we use for implementing language extensions avoid common pitfalls and challenges in combining languages. Furthermore, we enable the deployment of syntax extensions as separately compiled, binary plugins to an extensible compiler by a new algorithm for parse table composition. This drastically changes the way extensible compilers can be used by end-programmers. To give programmers better automated tools to analyze programs, we present a strictly declarative approach for the specification of sophisticated points-to analyses. Pointer analysis is the most fundamental program analysis and has a long and rich history of research and application. Our points-to analysis framework for Java, called Doop, builds on the idea of specifying pointer analysis algorithms declaratively, using Datalog: a logic-based language for defining (recursive) relations. We carry the declarative approach further than past work by describing the full end-to-end analysis in Datalog, which was thought to be impossible. The pointer analysis specifications are optimized aggressively through a novel technique that takes into account Datalog incremental evaluation. As a result, Doop achieves a full order of magnitude improvement in runtime over the current state of the art in context-sensitive pointer analysis. Additionally, Doop scales to very precise analyses that are impossible with previous pointer analysis algorithms, directly addressing open problems in past literature. ## Strictly Declarative Specification of Sophisticated Points-To Analyses <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/nyu09.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Presented at New York University, March 30, 2009 <p> Earlier version presented at University of Texas at San Antonio and the University of Massachusetts Amherst </p> </td></tr></table> We present the Doop framework for points-to analysis of Java programs. Pointer analysis is the most fundamental program analysis and has a long and rich history of research and application. Doop builds on the idea of specifying pointer analysis algorithms declaratively, using Datalog: a logic-based language for defining (recursive) relations. We carry the declarative approach further than past work by describing the full end-to-end analysis in Datalog, which was thought to be impossible. The pointer analysis specifications are optimized aggressively through exposition of the representation of relations (e.g. indexing) to the Datalog language level and a novel technique that takes into account Datalog incremental evaluation. As a result, Doop achieves a full order of magnitude improvement in runtime over the current state of the art in context-sensitive pointer analysis. Additionally, Doop scales to very precise analyses that are impossible with previous pointer analysis algorithms, directly addressing open problems in past literature. Finally, our implementation is modular and can be easily configured to analyses with a wide range of characteristics, largely due to its declarativeness. Our work is a strong data point in support of declarative languages: we believe that humans cannot implement and optimize well complex mutually-recursive definitions at an operational level of abstraction, but can do so using declarative specifications. The work also demonstrates that representing relations using binary decision diagrams, as in past precise pointer analysis work, is not essential for the most important configurations, and even detrimental to performance. ## Screaming Fast Declarative Pointer Analysis <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/nepls09.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Presented at New England Programming Languages and Systems Symposium Series (NEPLS), March 5, 2009 </div></td></tr></table> We present the Doop framework for points-to analysis of Java programs. Doop builds on the idea of specifying pointer analysis algorithms declaratively, using Datalog: a logic-based language for defining (recursive) relations. We carry the declarative approach further than past work by describing the full end-to-end analysis in Datalog and optimizing aggressively through exposition of the representation of relations (e.g., indexing) to the Datalog language level. As a result, Doop achieves stunning (full order-of-magnitude) improvements in runtime. We compare Doop with Lhotak and Hendren's Paddle, which defines the state of the art for context-sensitive analyses. For the exact same logical points-to definitions (and, consequently, identical precision) Doop is 12.9x faster than Paddle for a 1-call-site sensitive analysis of the DaCapo benchmarks, and 10.2x faster than Paddle for a 1-object-sensitive analysis. At the same time, our implementation is modular and can be easily configured to analyses with a wide range of characteristics, largely due to its declarativeness. # 2008 ## Pointer Analysis <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/lb08-pointer-analysis.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Presented at [[LogicBlox]], Atlanta, May 6, 2008 </td></tr></table> # 2007 ## Towards Intelligent Coding Assistance for Code Generation in Modeling Frameworks <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/modse-11-2007.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Delft University of Technology, The Netherlands, MoDSE Colloquium, November, 2007 </td></tr></table> Development environments for domain-specific language tools and model-driven development are currently mostly focusing on supporting the metamodelling and modelling aspects of model-driven engineering. The actual code generators are usually implemented in conventional template languages. Such template languages allow the metaprogrammer to write code templates using the syntax of the generated program, i.e. the syntax of the object language. The literal code of the program to generate can typically be mixed with meta constructs to generate code conditionally, iteratively, or based on properties of the input model. Unfortunately, the development environment nor the template engine give feedback about syntactic or semantic errors in the code templates. Hence, the only way to check if the code generator produces programs that actually compile is to apply the code generator to an input model. The disadvantage of this approach is that the metaprogrammer does not get immediate feedback about the validity of code generator when he is writing the code templates. During testing the syntactic or semantic errors need to be traced back to the code generator. Moreover, test models might not cover the entire code generator or the possible input models, so errors might be reported even after deployment of the code generator. Finally, there is no support for various forms of code completion and assistance, which are widely appreciated IDE features. Despite code generators being a major aspect of model-driven development, this makes the development of the actual code generator feel rather unsupported. Basically, the metaprogrammer leaves the shiny and supportive development environment for this important part of a model-driven engineering project. In academic research, a range of solutions have been proposed to make code generation tools syntactically or semantically aware of the object language. This awareness of the object language can be used to guarantee that the generated programs are always syntactically correct, or in the case of semantical awareness might even always compile. Also, this awareness could be used to support coding assistance. In this talk, I will first give a brief overview of the research in this area. I will discuss the various levels of understanding of the object program that have been researched. After this overview, I will take a closer look at a method for adding syntactical awareness of an object language to code generation tools. In particular, I will discuss the parsing techniques required for parsing combinations of a template language and possibly multiple object languages. These parsing techniques are applied in several academic tools that can be applied for code generation, e.g. the ASF+SDF MetaEnvironment, Stratego/XT, StringBorg, and Repleo. Finally, I will discuss the usability issues of the current academic tools that support syntactical awareness and challenges to apply these ideas in interactive development environments. ## Grammar Engineering Support for Precedence Rule Recovery and Compatibility Checking <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/ldta07-slides.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> LDTA 2007, Braga, Portugal, March 2007 <p> Based on article: <a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/ldta07.pdf">Grammar Engineering Support for Precedence Rule Recovery and Compatibility Checking</a> </p> </td></tr></table> # 2006 ## The State of Stratego/XT <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/sud06-state.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> <a href="http://www.stratego-language.org/Stratego/SeventhStrategoUserDays">Seventh Stratego User Days</a>, November 2006, Delft University of Technology, Delft, The Netherlands </td></tr></table> ## Introducing the Stratego Libraries <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/sud06-stratego-libraries.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> <a href="http://www.stratego-language.org/Stratego/SeventhStrategoUserDays">Seventh Stratego User Days</a>, November 2006, Delft University of Technology, Delft, The Netherlands </td></tr></table> ## MetaBorg: An Approach for Domain-Specific Language Embedding <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/modse-kickoff-metaborg.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> <a href="http://swerl.tudelft.nl/bin/view/MoDSE">MoDSE</a> (Model-Driven Software Evolution) kickoff meeting, 2006-11-17, Delft University of Technology, Delft, The Netherlands </td></tr></table> ## Declarative, Formal, and Extensible Syntax Definition for AspectJ. A Case for Scannerless Generalized-LR Parsing. <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/oopsla06-slides.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> OOPSLA 2006, Portland, USA, October 2006 <p> Based on article: <a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/oopsla06.pdf">Declarative, Formal, and Extensible Syntax Definition for AspectJ. A Case for Scannerless Generalized-LR Parsing.</a> </p> </td></tr></table> Aspect-Oriented Programming (AOP) is attracting attention from both research and industry, as illustrated by the ever-growing popularity of AspectJ, the de facto standard AOP extension of Java. From a compiler construction perspective, AspectJ is interesting as it is a typical example of a <em>compositional language</em>, i.e. a language composed of a number of separate languages with different syntactical styles: in addition to plain Java, AspectJ includes a language for defining pointcuts and one for defining advices. Language composition represents a non-trivial challenge for conventional parsing techniques. First, combining several languages with different lexical syntax leads to considerable complexity in the lexical states to be processed. Second, as new language features for AOP are being explored, many research proposals are concerned with <em>further extending</em> the AspectJ language, resulting in a need for an extensible syntax definition. This paper shows how <em>scannerless parsing</em> elegantly addresses the issues encountered by conventional techniques when parsing AspectJ. We present the design of a modular, extensible, and formal definition of the lexical and context-free aspects of the AspectJ syntax in the Syntax Definition Formalism SDF, which is implemented by a scannerless, generalized-LR parser (SGLR). We introduce <em>grammar mixins</em> as a novel application of SDF's modularity features, which allows the declarative definition of different keyword policies and combination of extensions. We illustrate the modular extensibility of our definition with syntax extensions taken from current research on aspect languages. Finally, benchmarks show the reasonable performance of scannerless generalized-LR parsing for this grammar. ## Infrastructure for Java Program Transformation <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/PT05-Java-Infrastructure.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Master Course Program Transformation, Utrecht University, 2006-02-09 </td></tr></table> ## Infrastructure for Program Transformation Systems <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/PT05-Infrastructure.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Master Course Program Transformation, Utrecht University, 2006-02-07 </td></tr></table> # 2005 ## Components: Concepts and Techniques <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/SWE05-CBSE.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Software Engineering Course, Utrecht University, 2005-10-19 </td></tr></table> ## Testing Tools and Techniques <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/SWE05-TestingTools.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Software Engineering Course, Utrecht University, 2005-10-12 </td></tr></table> ## Generalized Type-Based Disambiguation of Meta Programs with Concrete Object Syntax <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/gpce05-slides.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> GPCE 2005, Tallin, Estonia, 2005-09-30 <p> Based on article: <a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/disamb-gpce05.pdf">Generalized Type-Based Disambiguation of Meta Programs with Concrete Object Syntax</a> </p> </td></tr></table> In meta programming with concrete object syntax, object-level programs are composed from fragments written in concrete syntax. The use of small program fragments in such quotations and the use of meta-level expressions within these fragments (anti-quotation) often leads to ambiguities. This problem is usually solved through explicit disambiguation, resulting in considerable syntactic overhead. A few systems manage to reduce this overhead by using type information during parsing. Since this is hard to achieve with traditional parsing technology, these systems provide specific combinations of meta and object languages, and their implementations are difficult to reuse. In this paper, we generalize these approaches and present a <em>language independent</em> method for introducing concrete object syntax without explicit disambiguation. The method uses scannerless generalized-LR parsing to parse meta programs with embedded objectlevel fragments, which produces a forest of all possible parses. This forest is reduced to a tree by a disambiguating type checker for the meta language. To validate our method we have developed embeddings of several object languages in Java, including AspectJ and Java itself. ## MetaBorg in Action: Examples of Domain-specific Language Embedding and Assimilation using Stratego/XT <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/gttse05-slides.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Summer School on Generative and Transformational Techniques in Software Engineering (GTTSE 2005), Braga, Portugal, July, 2005. </td></tr></table> ## Dryad & Java Front. Infrastructure for Java Transformation Systems <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/sud05-dryad.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> <a href="http://www.stratego-language.org/Stratego/SixthStrategoUserDays">Sixth Stratego User Days (SUD 2005)</a>, Utrecht University, 2005-05-03 </td></tr></table> ## The State of Stratego/XT <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/sud05-state.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> <a href="http://www.stratego-language.org/Stratego/SixthStrategoUserDays">Sixth Stratego User Days (SUD 2005)</a>, Utrecht University, 2005-05-03 </td></tr></table> ## Meta Programming with Concrete Object Syntax <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/PT04-ConcreteObjectSyntax.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Master Course Program Transformation, Utrecht University, 2005-03-08 </td></tr></table> ## Infrastructure for Program Transformation Systems (Extended version) <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/PT04-Infrastructure.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top">Master Course Program Transformation, Utrecht University, 2005-02-10</td></tr></table> ## Infrastructure for Program Transformation Systems <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/philips-2005-infrastructure.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Stratego/XT Tutorial at Philips, Eindhoven, The Netherlands, 2005-01-24 </td></tr></table> # 2004 ## Concrete Syntax for Objects <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/OOPSLA04-CSfO.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> OOPSLA'04, Vancouver, Canada, 2004-10-28 <p> Based on article: <a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/BV04.pdf">Concrete Syntax for Objects</a> </p> </td></tr></table> Application programmer's interfaces give access to domain knowledge encapsulated in class libraries without providing the appropriate notation for expressing domain composition. Since object-oriented languages are designed for extensibility and reuse, the language constructs are often sufficient for expressing domain abstractions at the semantic level. However, they do not provide the right abstractions at the syntactic level. In this paper we describe MetaBorg, a method for providing concrete syntax for domain abstractions to application programmers. The method consists of embedding domain-specific languages in a general purpose host language and assimilating the embedded domain code into the surrounding host code. Instead of extending the implementation of the host language, the assimilation phase implements domain abstractions in terms of existing APIs leaving the host language undisturbed. Indeed, MetaBorg can be considered a method for promoting APIs to the language level. The method is supported by proven and available technology, i.e. the syntax definition formalism SDF and the program transformation language and toolset [[Stratego]]/XT. We illustrate the method with applications in three domains: code generation, XML generation, and user-interface construction. ## Components: Concepts and Techniques <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/SWE04-CBSE.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td> <td valign="top"> Software Engineering Course, Utrecht University, 2004-10-12 </td></tr></table> ## Testing Tools and Techniques <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/SWE04-TestingTools.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Software Engineering Course, Utrecht University, 2004-09-30 </td></tr></table> ## Concrete Syntax for Objects <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/STC-ConcreteSyntaxForObjects.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Software Technology Colloquium, Utrecht University, 2004-06-03 </td></tr></table> ## Stratego Shell <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/stratego-shell-sud2004.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Fifth [[Stratego]] User Days, Utrecht University, 2004-03-01 </td></tr></table> ## Language Engineering Tools Presented at the Fifth [[Stratego]] User Days, Utrecht University, 2004-03-01 [![[pdf-logo.png|50]]](https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/language-engineering-sud2004.pdf) ## XTC Support in the Stratego Shell <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td ![[pdf-logo.png]]valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/xtc-shell-sud2004.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Fifth Stratego User Days, Utrecht University, 2004-03-03 </td></tr></table> ## XML Processing and Term Rewriting <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/pt-xml-2004.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Program Transformation course, Utrecht University, 2004-02-21 </td></tr></table> # 2003 ## Connecting XML Processing and Term Rewriting with Tree Grammars <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/mbravenboer-masterthesis-talk.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Software Technology Colloquium (Master talk), 2003-11-20 </td></tr></table> ## XML Transformations and Distributed Services: Stratego & XML <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/pt-xml.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Program Transformation course, Utrecht University, 2003-02-17 </td></tr></table> # 2002 ## JavaFront: Techniques and Applications <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/java-front-trafo-2002.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Trafo Meeting, Utrecht University, September 17, 2002 </td></tr></table> ## Making XT XML capable <table style="margin-left: 20px; margin-top: 8px; margin-bottom: 5px;"><tr><td valign="top"><a href="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/xml-pem-2002.pdf"><img src="https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/images/pdf-logo.png" style="margin-right: 20px"/></a></td><td valign="top"> Centrum voor Wiskunde en Informatica (CWI), May 30, 2002 </td></tr></table> ## Term Annotation in Stratego Presented at the Third [[Stratego]] Users Day, May 3, 2002 [![[pdf-logo.png|50]]](https://s3.us-west-2.amazonaws.com/martin.bravenboer.name/docs/stratego-annotations-2002.pdf)