deosjr

Working on my version of Dynamicland. Today I got this small thing working where I can now live-edit the behaviour of the editor script, see https://www.youtube.com/shorts/ZjxPIv-XwoU

Repo is here if anyone wants to have a look: https://github.com/deosjr/unreal-talk

And a browser-based version can be found here: https://deosjr.github.io/dynamicland/live

Wow that is cool, thanks for that!

This might be your jam. I should revisit this, most of it is unimplemented. But the parsing part was interesting, since MTG has such a codified language for explaining the rules. My idea here was to take a card's rules text from the official API and parse it into smth that can be used in the game, so you could keep up with new sets with implementation. The weird rule-breaking edge cases will always fail, but a large set of design space can fit, I think.

See https://github.com/deosjr/pmtg/blob/master/parse.pl

A while ago I was playing the romhack Run&Bun, which drastically ups the difficulty of Pokemon Emerald. Watching others play, most of the game was doing 'calcs': calculating how to approach a battle. This was done using a javascript frontend to a simulator, and a lot of excel sheets.

So I forked the calculator and added a Prolog wrapper so I could find solutions to battles based on the team of Pokemon that I caught. https://github.com/deosjr/runbuncalc/blob/master/main.pl

My runs died pretty early, but there are some notes here as I was implementing that are fun to read. I implemented each battle as a test case and let my solver find a solution, then amended the plan and commented on what actually happened. For example: https://github.com/deosjr/runbuncalc/blob/master/run10.pl#L2...

Such an amazing project.

I've made a lot of progress recently working on my own homebrew version, running it in the browser in order to share it with people. Planning to take some time soon to take another stab at the real (physical) thing.

Progress so far: https://deosjr.github.io/dynamicland/

Exploring the implementation of Dynamicland (dynamicland.org) using Guile Scheme, Hoot (scheme->wasm) and miniKanren. Main write-up can be found here: https://deosjr.github.io/dynamicland/

I cycle between learning about scheme macro hygiene and implementing more and more realtalk/dynamicland demos and trying to grok the programming model. Doing this in the browser is a weird but fun constraint that makes things shareable.

My latest project is a wikipedia explorer: https://deosjr.github.io/dynamicland/wiki.html

I recently shared a project I did using Hoot, by Spritely institute. It's Guile Scheme compiling to WASM, and it works really well! See https://spritely.institute/hoot/

Latest on my project, in case you want to try it out: https://deosjr.github.io/dynamicland/whiskers.html

Cheers, this is super useful. I will have to do some reading. Being able to build up n-ary predicates using triples that way makes a lot of sense.

Thanks Dave, high praise! I was inspired after seeing you all take over the declarative & minimalist programming room at FOSDEM this year.

If you thought this was cool, wait until you see what I ended up using it for: https://deosjr.github.io/dynamicland/ I personally think this is much cooler :) But it needs some more explaining before I can broadly share, I think.

Now that I have you here, a question: am I correct in thinking that in Hoot, eval in the browser does not currently work with macros?

I appreciate it; this kind of exchange is exactly why I read HackerNews. If you have any good sources on extending Datalog to N-ary relations, I'd love to know. Just had a look at the implementation I based mine on and it exclusively talks about triples: https://www.instantdb.com/essays/datalogjs

Coming from Prolog I'd like to get closer to the original if possible :)

Thank you for the feedback! I agree with all of the above.

Should've probably been a bit more clear on the dl-find syntax; I find it just as unacceptable as you do. It is the result of laziness: my intended use of this minimal Datalog does not include any querying whatsoever but abuses fixpoint analysis for side-effects (see https://github.com/deosjr/deosjr.github.io/blob/master/dynam... which I intend to go over in a future post). I initially had it working like you described but butchered it for the above and haven't repaired it yet (see https://github.com/deosjr/whistle?tab=readme-ov-file#datalog). This version relied on some monstrous eval-hacking using a homebrew Lisp, which I've mostly cleaned up now in this version (https://github.com/deosjr/whistle/blob/main/datalog/datalog.... is a crime, for example).

The semantics are indeed limited to binary relations atm, which I agree is the main thing that disqualifies this as a proper Datalog. iirc the tutorial on Datalog that I based this implementation on only handled triples as well so I stopped there, but extending to N-ary relations is on my list to look into for sure.

Guile Scheme. See https://github.com/deosjr/deosjr.github.io/blob/master/dynam... for more.

Seems like interest in Datalog is high this week, so I thought I'd share a write-up of a minimal Datalog implementation I did a while ago.

Runs in the browser using Hoot (https://spritely.institute/hoot/) which compiles Guile Scheme to WebAssembly.

I recently implemented a version of Bret Victor's Dynamicland in the browser using miniKanren, Datalog, and WebAssembly: https://deosjr.github.io/dynamicland/

Knowing how to implement a small logic programming language from scratch really feels like a superpower sometimes.

A bit late, but just saw this and wanted to say I appreciate the minimalism of this a lot!

I did the same thing in Golang here: https://github.com/deosjr/nand2tetris

Be sure to check out the lispmachine folder; its essentially a fork I made after finishing the course. It implements a Lisp on the nand-gate level :)

That's exactly why I built my own tooling when going through the book. I built everything in Golang and am working on some visualisations in Javascript. Repo: https://github.com/deosjr/nand2tetris Website: https://deosjr.github.io/ (lispmachine part is wip)

Here's a gist in Prolog that I believe solves this puzzle: https://gist.github.com/deosjr/7314659509333ee2ad67dbf276e8d...

My way of learning about Lisp was based on first principles, after reading Norvigs blogpost many times and working through SICP. What helped is that I had just finished the nand2tetris book, which is very much a first principles speedrun of how a computer works.

So I built my own Lisp machine based on the nand2tetris architecture, with lisp instructions supported on the simulated chip level. I'm currently in the progress of doing a writeup of the project, you can see my attempts here if you are interested: https://deosjr.github.io/

I have an almost working version of a REPL running on the machine now, including garbage collection and parsing Lisp with Lisp and passing the output to an eval function written in assembly (the operating system, if you will).

I tried for a bit and couldn't get it to work either. The dragon curve example is a lot more complicated than the simplest definition, which is a hint. I don't even know exactly what | or [ or ] are supposed to do here.

Here's a version in Go instead: https://github.com/deosjr/GenGeo/blob/master/gen/lindenmayer... Which renders into: https://github.com/deosjr/GenGeo/blob/83c77f9433e569b30f71b3... (see Algorithmic Beauty of Plants for way more examples)

http://algorithmicbotany.org/papers/abop/abop.pdf

Glad to hear from Dynamicland; the last video got me so excited I decided to try and build a demo for tinkering with at home: https://github.com/deosjr/elephanttalk

Only dependency is on openCV through GoCV, otherwise pure Go. Supports a webcam/beamer setup. Uses Lisp for scripting instead of Lua (see https://github.com/deosjr/elephanttalk/blob/main/cmd/elephan...).

It's a lot slower/less mature than paperprograms, but it does attempt to implement the wish/claim/when model using a homebrew datalog implementation :)