Are there qwen or minimax or other open weight models of same hardware requirements that outperform this?

  Location: Slovakia (GMT+1)
  Remote: Yes
  Willing to relocate: No
  Technologies: Clojure, Docker, Common Lisp, Bash/Zsh, Python ...
  Email: petern@riseup.net

Résumé/CV: https://drive.google.com/file/d/1YzYDnSo-u823VNVIljVHH6vt8cd...

I am currently a core maintainer of Electric Clojure (https://github.com/hyperfiddle/electric), a full-stack, reactive, differential language we use for building rich, dynamic UIs. Most notably I developed the last 2 generations of our compiler and pioneered the UI composition pattern we use today. I work with Clojure for 7+ years, but also did a lot (4y+) of infrastructure work before - Docker, Kubernetes, ELK stack, Kibana and more. I worked in many other languages. I am a systems-level thinker who derives solutions from first principles. I am looking for a new challenge.

If the problem fits into the limited local resources, if there's no syncing required, no login, no multiplayer, ... Sure, do it. But don't pretend this solves all business cases.

Instead of doing the side effect you return a description and let the framework handle it. E.g. you don't call `transact(db, data)` but return `["transact", db, data]`. Now your function is pure. The framework will expect you to provide the transact handler, e.g. as `register_handler("transact", (db, data) => {..})`.

Personally I'm not a fan of this abstraction (another layer of indirection). I'd rather take a `transact` function as an argument.

The only way for the client to set a server-side symbol to a value is to explicitly request it in code

    (e/server (let [is-admin? (e/client ...)]))

Even with mutable atoms you'd have to write the `reset!` on the server.

I think SBCL starts up fast enough as-is, no? If you want a batteries included version with libraries, just load them and save a new base image with SAVE-LISP-AND-DIE

So it's OK to let them spy since we get spied on from other sources anyway.

libmill's goal was to be as close to Go as possible. If you look at it in that light, it's an accomplishment.

Then came libdill, which created the whole "structured concurrency" movement and brought new concepts to light that are now being replicated in python, kotlin, java...

I'll wait for the 1-line APL/J/K implementation in the comments.

Challenge Accepted!

Here is the core: using UDLR unlike the article

    snake←{d←9 11○0J1\*'DRUL'⍳⍺ ⋄ n←(⍴⍵)|(⊣/c)+-⍣(d≡p)⊢d⊣p←-⍨/c←(⍴⍵)⊤2↑⍒,⍵ ⋄ b←(1+⌈/,⍵)@(⊂n)⊢⍵ ⋄ ¯1=n⌷⍵:1-⍨@(⊂(?∘≢⊃⊣)⍸0=⍵)⊢b ⋄ 1-⍨@(0∘<)⊢b}

Here's a rudimentary display function that displays a list of moves:

    ∇display moves
    colours←↑(0 255 0)(0 0 0)(0 0 255)(255 0 0)                               ⍝ green black blue red
    'b'⎕WC'Bitmap'('Bits'(0 0⍴0))('CMap'colours)                              ⍝ create bitmap
    'f'⎕WC'Form' 'Snake demo'('Size' 500 500)('Coord' 'pixel')('Picture'b)    ⍝ create form with b as the background
    s←1 ¯1@(⍉↓10 10⊤2?100)⊢10 10⍴0                                            ⍝ start position
    b.Bits←50/50⌿(¯1 0 1,⌈/,s)⍸s                                              ⍝ display snake
    :For move :In moves                                                       ⍝ loop over moves
        s←move snake s                                                        ⍝ update using 'snake' function
        b.Bits←50/50⌿(¯1 0 1,⌈/,s)⍸s                                          ⍝ update bitmap
        ⎕DL÷50                                                                ⍝ delay by 1/50 s
    :EndFor
    ∇

Here's a video of the result: https://twitter.com/rak_1507/status/1557869849631670274?s=20