4 posts tagged with "readings"

I just read Logic-flow analysis of higher-order programs by Matt Might.

Great paper, and had a lot of the ideas that were spinning around in my mind. Matt Might has done a ton of work in so many areas of control flow analysis that it boggles my mind.

The related work section at the end includes many references that I'd like to read to understand more in this area. However, I feel like egglog supersedes this work, with a lot of the same ideas but in a better framework for extending and experimenting with the ideas.

I watched a good video on Delimited Continuations from Alexis King last night. She explains them very well both semantically and with some examples. I'm glad to see that native support for them has been introduced to Haskell.

In figuring out what approach to take for my full program analysis for algebraic effects, I'm looking into a few things:

One is this paper Functional derivation of a virtual machine for delimited continuations, which I think was recommended to me by Kimball when I was first looking into algebraic effects, and first learning about control flow analyses. I'll probably also look into both the typed directed continuation passing style transformation that was originally implemented for Koka, as well as the more recent Generalized evidence passing for effect handlers: efficient compilation of effect handlers to C.

As far as progress today on figuring out some benchmarks for how to improve Koka's performance, I've added some basic benchmarks, but there is still more research to go, to really show the difference. I wish there were more real-world example programs I could benchmark the changes on. I'm sure I'll be contributing to that due to my interest in Koka. I mostly spent time on the benchmarking scripts, but in doing so I also added / exposed a few methods for dealing with getting file information.

I just read Better Together: Unifying Datalog and Equality Saturation.

A lot of good ideas in this paper. I'm interested in trying to use it for some of our analyses, or to implement a simple type system. However, like most logic languages I wonder how hard it is to for example read and parse a file, or if you need to parse a program in a more traditional language and then generate the egglog code for analyzing the program after the fact.

Anyways, the full version of the paper is on arxiv and includes an appendix with practical examples. The repo says that the python binding has a bit more documentation, but the link is bad. The rust crate has some docs but mostly for the api bindings and not the language itself. So I guess I'll be looking into the appendix of their extended paper if I want to learn more.

From the same conference (PLDI) I watched the presentation for this paper, as well as another talk from that section about Indexed Streams which was also interesting, but not really related.

First blog post about readings of papers. This one is called Better Defunctionalization through Lambda Set Specialization.

The basic idea is to keep track of the lambdas that could flow to a particular location in the type system as a sort of set / effect type.

This allows for a large majority of call sites to reference first order functions, with just tags for which lambda is being called.