#minikanren

[forvillelser]

William Byrd - The most beautiful program ever written

Awesome talk on Lisp, miniKanren and program synthesis.

[reborg-blog]

Clojure Weekly, May 29th, 2014

Welcome to another issue of Clojure Weekly! Here I collect a few links, normally 4/5 urls, pointing at articles, docs, screencasts, podcasts and anything else that attracts my attention in the clojure-sphere. I add a small comment so you can decide if you want to look at the whole thing or not. That’s it, enjoy!

Functional Geekery Episode 9 – William E. Byrd Enjoyed listening to this episode of the Functional Geekery podcast (and all the others by the way). I had the pleasure to attend a couple of pair-talks by Wll Byrd and Daniel Friedman and appreciated their style presenting dense topics with a bit of humour. I'm fascinated by logic programming and what you can achieve declaratively. I think the big jump from FP to logic happens when you stop thinking about input and output as two different things. In logic programming you can very well feed the output of a function (or the output evaluation of a compiler) back as input and generate a set of all the solutions that can produce that output. William also remembers us that despite not conquering the entire world, logic programming has found specific niches where it has no rivals, like embedded query engines like the datalog engine in Datomic.

Session — Erlang, Lisp and Haskell — Medium Session is a REPL on steroids, an all-evaluable Clojure scratchpad that remembers LightTable but also allow for graphics and other fancy output, not just text. It is backed by a Datomic database, so sessions are persistent and stored. It uses some other fancy new tech like Om and designed to be extensible and modular (such as, replace the rendering engine if you need to). One application that comes into mind is creating custom editors for specific DSL, replacing the need of editing configuration files for example.

How Clojure works: a simple namespace : Deep Blue Lambda This is probably the best article so far of the series "clojure internals". It explains what happens in case of a bare bone new namespace declaration. One of the most interesting facts is that a new namespace always trigger first thing a push of a new class loader into the thread bound table of Vars. Translated it means that from that moment on, all the functions declaration that will follow in the namespace will be loaded by a new instance of DynamicClassLoader custom class loader. I suppose this is a wise decision, since the dynamicity of Clojure will allow me to redefine functions at anytime in that namespace, resulting in a class being thrown away and a new class being generated and loaded. The DynamicClassLoader contains a weak reference cache that makes this process easier. Not sure about all the details yet, but very interesting stuff.

MailOnline/s-metric Quick and hopefully useful self-promotion. This little library implements a couple of easy algorithms for string matching and scoring. The typical use case is to compare a first string to another one and see how visually similar they are. For this the "naive" implementation presented here can be sufficient. But string matching theory is way more complicated than this :) so other interesting algos will be added soon. Clojure here shines for quick implementation of fairly complex recursive behaviour. If you need to push performances to the next level though, it takes some more Java knowledge and pre-processing with useful data structures.

Getting Started with Textmate | Clojure Project | Assembla Linking here another piece of abandoned Clojure history. The Assembla wiki was adopted some point in 2009 and then abandoned to move under the clojure.org umbrella. There is not a lot there, except a few design scratch pad about some of the Clojure features built at that point. The page about the clojure compiler in clojure is a summary about some of the desired features of a a new compiler, nowadays tools.analyzer and friends.

ClojureDocs - clojure.core/take-while take-while is often the answer to the question "how do I cut short a loop" for people coming from a Java background. The lazy way to "cut short" can be implemented with a take-while that stops a sequence the first time the given predicate becomes true. It can be used perfectly fine with the for comprehension (which is just another way to create a lazy sequence) without the need for a "break" construct.

galdolber/clojure-core-java Quite an interesting investigation project from the same author of clojure-objc. This is what happens if you take a very simple Clojure hello world, even just a namespace declaration and AOT compile it. You'll see a bunch of classes are generated. This project is the correponding Java source for the byte code that Clojure generates. By no mean this should be used, but it gives an impression of what is going on under the hood. You can obtain similar results by decompiling Clojure, but this is already done for you if you need a quick glance.

[fuckyeahpapers]

Jason Hemann, Daniel P. Friedman

Indiana University

This paper presents μKanren, a minimalist language in the miniKanren family of relational (logic) programming languages. Its implementation comprises fewer than 40 lines of Scheme. We motivate the need for a minimalist miniKanren language, and iteratively develop a complete search strategy. Finally, we demonstrate that through sufficient user-level features one regains much of the expressiveness of other miniKanren languages. In our opinion its brevity and simple semantics make μKanren uniquely elegant.

[bloidonia]

A miniKanren in Groovy

Finally got a working implementation of a miniKanren in Groovy (I basically ported the ruby version that can be found here).

It interests me, as it allows you to write code like this:

That prints:

Obviously, this simplistic example could be done in native groovy like so:

And it's a bit clunky at present (need to encode and unencode numbers, etc), but it's nice to have it working.

@tim_yates