Stratego

Stratego is a declarative language for the implementation of program transformation systems (for example compilers) as term rewriting systems. Term rewriting is a declarative approach for the implementation of program transformations. Stratego is a language that uses declarative rewrite rules, but gives some control over how the rewrite rules are applied. This helps with keeping the rewrite rules clean and unencumbered by the details of rewriting strategies (like number of passes and order). Stratego was created by Prof Eelco Visser. The original paper describing the ideas behind Stratego is A Core Language for Rewriting.

I was one of the main developers of the Stratego/XT program transformation system, which combines the Stratego language with tools for implementing end-to-end program transformations (eg parsers, pretty-printers, libraries). A good introduction to the system is the system paper Stratego/XT 0.17: A Language and Toolset for Program Transformation.

After I started my work on Doop, the Stratego team moved to develop Spoofax, which is an implementation of Stratego and related tools in for the JVM, primarily offered as an Eclipse plugin.

I personally still have a soft spot for the original command-line (C) implementation of Stratego/XT. The Stratego/XT implementation has not been maintained since 2009, but I have recently started working on restoring the implementation to properly function on modern operating systems. This is still very much work in progress. I will make an announcement here when it is in usable state.

• https://github.com/mbravenboer/strategoxt
• https://github.com/mbravenboer/sdf
• https://github.com/mbravenboer/aterm

Doop

Available at https://github.com/plast-lab/doop

Doop is a declarative pointer analysis framework. I developed the initial version of Doop as a postdoctoral researcher with Prof. Yannis Smaragdakis. The Doop framework uses Datalog, initially with the commercial LogicBlox engine, LogicBlox was was later replaced with the open source Soufflé implementation of Datalog.

I loved developing Doop and pushing the boundaries of declarative program analysis. The Doop logic very much stretches the capabilities of any Datalog engine out there and is still often used as a benchmark in new research work on Datalog and program analysis.

The original paper on Doop is Strictly Declarative Specification of Sophisticated Points-to Analyses in OOPSLA 2009. At the Doop website you can find many more recent resources and tutorials on how to use it.

Prof. Smaragdakis and his collaborators continued to develop the Doop framework far beyond my initial work. He also started a software analysis company that uses Datalog: Dedaub.

As far as I know, there is no public explanation for the inspiration of the name Doop. It is based on the song Doop by the band Doop from the Netherlands. As you will see, I find it quite amusing to hear about Doop in serious academic talks. It's best if Doop is repeated frequently.

LogicBlox

LogicBlox was used by the initial version of the Doop pointer analysis framework. The Doop framework was based on LogicBlox v3 (LB3). LB3 which uses DRed for incremental maintenance of updates and semi-naive evaluation for incremental evaluation in recursion. I later joined LogicBlox, initially focusing on the compiler implementation, later more on the overall architecture of the system and its applications. LogicBlox v3 is available as binary, look for PA-Datalog at https://github.com/plast-lab/doop .

The LogicBlox database engine was significatly rewritten with better query evaluation algorithms for complex logic, resulting in what is known as LogicBlox v4 (LB4). This later version is unfortunately not publicly available. The company LogicBlox was acquired by Infor and it is unclear how to obtain LB4 at this point.

Some resources for the architecture and purpose of the LogicBlox system:

• Design and Implementation of the LogicBlox System
• Talk at Splash 2013: Declarative Programming for the Cloud ( slides )

RelationalAI

RelationalAI is a knowledge graph management system. For RelationalAI, I designed the Rel language and wrote the original compiler. I learned a lot from the time at LogicBlox on how to approach the design of incremental/live database systems. The combination of a compiler and a data management system makes this a very interesting problem. The experience at LogicBlox had a great influence on how we approached the RelationalAI architecture, which is from the ground up designed to be live environment. I expect there will be some architecture papers coming out in the future. Unfortunately, there is no unconstrained version of the Rel language and RelationalAI system publicly available to use. Hopefully this will be released in the future.

The best resource on the technical architecture of the full RelationalAI system is my CMU talk Design and Implementation of the RelationalAI System.