hyper.dev

Cross-compiling Racket’s Chez

Wed, 12 Apr 2023 00:00:00 +0000

Racket team lead by Matthew Flatt did an awesome work on Chez Scheme such as aarch64 support, that means you can use Chez on Raspberry Pi 400. Problem is Raspberry Pi 400 is very slow, hence it is better to compile things on another machine.

I used to rely on QEMU, LXC, LXD, then Docker, and podman; this tutorial describe the best workflow I know today to test, and build software across distributions, and across architectures.

I work on a Lenovo laptop with Ubuntu, and Alpine on the RasperryPi 400. While I can not claim to be able to reproduce the same environment across distro… I can haz Chez^W letloop where ever that matters thanks to Matthew Flatt, and the other awesome people, and companies making code available on the Internet.

I want to demonstrate how to use systemd’s Linux container wrapper aka. systemd-nspawn, and QEMU, a full hardware emulator that can run any Operating System to compile anything from where you are. Moreover Linux kernel has the ability to run arbitrary executable file formats, and rely on QEMU to execute binaries from other architectures via binfmt_misc. With that ability, it possible to use a root filesystem for a distribution built for any arch supported by QEMU, and nspawn inside it, and then compile Chez (or whatever) with ease.

Note: I tried chroot, and proot, as of 2023, systemd’s nspawn works better. Docker, and podman should work.

On the shoulder of giants, that suite of tools allow to cross compile anything from your host with a recent Linux kernel, systemd, QEMU, a rootfs, and that is done without the need to change the build scripts of the software you want to compile.¹

To get started on Ubuntu Jammy 22.04, you need the help of apt:

#;sh> sudo apt install systemd-container qemu-user-static

Canonical makes available several root filesystem for several architectures, here we will use Alpine arm64 available at:

https://uk.lxd.images.canonical.com/images/alpine/3.17/arm64/default/

Pick the latest, you will be good.

Somewhere in your home directory, extract that archive, like:

#;sh> mkdir -p ~/rootfs/alpine/3.17/arm64/
     #;sh> cd ~/rootfs/alpine/3.17/arm64/
     #;sh> wget https://uk.lxd.images.canonical.com/images/alpine/3.17/arm64/default/20230412_13:02/rootfs.tar.xz
     #;sh> tar xf rootfs.tar.xz

Before calling tar, you may verify the file rootfs.tar.gz with the hash found in the file next to it called SHA256SUM.

As of 2023, you still need sudo rights to use systemd-nspawn,² once you hit enter, you will enter Alpine arm64 from your host:

#;sh> sudo systemd-nspawn --uuid=$(systemd-id128 new) -D $(pwd)
     [sudo] password for amirouche:
     Spawning container blog on /home/amirouche/rootfs/blog.
     Press ^] three times within 1s to kill container.
     alpine:~#

You can triple check that it is indeed arm64^W aarch64 with the following:

alpine:~# uname -a
     Linux blog 5.19.0-38-generic #39~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Fri Mar 17 21:16:15 UTC 2 aarch64 Linux

We will proceed with compiling Chez, before, let’s install dependencies, among other things, git:

alpine:~# apk add build-base git lz4-dev libuuid util-linux-dev zlib-dev

Then the usual hip command line dance hop that may take a while:

alpine:~# git clone https://github.com/racket/chezscheme
     alpine:~# cd chezscheme
     alpine:~# ./configure --threads --disable-x11 --disable-curses
     alpine:~# make -j $(nproc)
     alpine:~# make install
     alpine:~# scheme --version

Let there be loops ;-)

Look into “cross compilation late night hell” if you want to know how hard that can be↩︎
Send me an email if that change↩︎

Petit Cloud - 0 - Specification

Thu, 13 Apr 2023 00:00:00 +0000

You may remember the days of html, dynamic or not, php3, funny, and funky under construction 🚧… Ah!… While the visual aesthetic can remain in the past, the ease, and simplicity to create, show, and tell used to be simpler, easier, and more fun. Petit Cloud is a demonstration that the 90s, early 00s workflow can be implemented for fun with our favorite material.

Any resemblance to competitor technology is wholly, and fully coincidental.

Specification

The interface can not be simpler. Given a www.scm with an exported procedure main, it should be possible to do the following:

#;sh> petit-cloud deploy www.example www.scm

Here the intent is to deploy the code of WWW.SCM including dependencies, to WWW.EXAMPLE, both are parameter, and may be changed at will.

At this point jumping to https://www.example/ should display page associated with the root path.

The procedure MAIN is the request handler. It takes as argument the HTTP request parts:

method
url
headers
body

It is expected to return three values:

integer
headers
body

BODY is always a bytevector. headers is an list mapping a symbol to a string. URL is the complete Universal Ressource Location including scheme, host, path, query string, and fragment as a list. Here is a possible value for URL:

(assert (equal? url (list 'https
                               (list "example" "www")
                               (list "path" "to" "object")
                               (list (cons 'q "freedom"))
                               (list))))

A hello world MAIN can look like:

(define main
       (lambda (method url headers body)
         (match (cons method path)
           (() (values 200
                       '((content-type . "text/plain"))
                       (string->utf8 "Hello schemer!")))
           (else (values 404
                         '((content-type . "text/plain"))
                         (string->utf8 "Nothing here, error 404!"))))))

Furthermore, a couple of procedure should be made available:

www-form-urlencoded-read that helps with forms;
jsonify that takes a scheme objects as argument, and returns the bytevector made of its JSON representation;
htmlify same as jsonify for HTML.

Go back, rest, think, and eat your vegetables.

Petit Cloud - 1 - Kickstart

Thu, 13 Apr 2023 00:00:00 +0000

In the previous article, we set a goal to deploy a program in one hip command line hop, let’s kickstart the code with an outline of the application server.

Any resemblance to competitor technology is wholly, and fully coincidental.

Continuation

We want to deploy http web application stuffed into a hello library that looks like the following:

;; hello.scm
     (library (hello)
       (export main)
       (import (petit-cloud application))
     
       (define main
         (lambda (method path headers body)
           (values 200
                   (list (cons 'content-type "text/plain"))
                   (string->utf8 "Hello schemer!\n")))))

The expected, so called workflow, is that given an existing application server running at www.example:9999, we want to deploy the above library with the following one-liner:

#;sh> petit-cloud deploy www.example:9999 hello.scm

When that command is issued, we will be prompted for a password, after a nanowhile, we will be able the manually test it with:

#;sh> curl http://www.example:9999
     Hello schemer!

The application server will be listening to port 9999 of all available network interfaces, that can be done with:

(define-values (client-accept close)
       (petit-cloud-http-connect "0.0.0.0" 9999))

The variable client-socket is a generator of three objects read, write, and close, that work as follow:

(read) will produce a representation of an HTTP request;
(write object) will write OBJECT as an HTTP response;
(close) will close the connection.

The simplest way to use it is:

(define-values (client-accept close)
       (petit-cloud-http-connect "0.0.0.0" 9999))
     
     (define-values (read write close)
       ;; client-accept will pause
       ;; until a HTTP request hit
       ;; the port 9999
       (client-accept))
     
     (define-values (method url headers body) (read))
     ;; let's reply
     (write 200
            (list (cons 'content-type "text/plain"))
            (string->utf8 "Hello schemers\n"))
     (close)

It is possible accept multiple clients simultaneously, by passing a procedure to petit-cloud-http-connect:

(define client-accept
       (lambda (read write close)
         ;; where is everyone
         (define-values (method url headers body) (read))
         ;; reply
         (write 200
                (list (cons 'content-type "text/plain"))
                (string->utf8 "Hello schemers\n"))
         ;; the end
         (close)))
                
     (petit-cloud-http-connect "0.0.0.0"
                               9999
                               client-accept)

The command call petit-cloud deploy will hit the application server with a method that is the symbol 'POST, and an url that is:

(list 9999
           (list "example" "www")
           ("_" "api" "petit" "cloud")
           (list)
           (list))

And the body is the bytevector representation of hello.scm at the start of the article.

We can implement a predicate that returns #t when it is a call by petit-cloud deploy:

(define petit-cloud-deploy?
       (lambda (method path)
         (equal? (cons 'POST 
                       (list 9999
                             (list "example" "www")
                             ("_" "api" "petit" "cloud")
                             (list)
                             (list)))
                 (cons method path))))

If the request is not a deployment, we fallback to the application procedure returned by the parameter petit-cloud-current-application.

At this point, and without any error handling, our application server code looks like the following:

(import (petit-cloud))
     
     
     (define petit-cloud-deploy?
       (lambda (method path)
         (equal (cons 'POST 
                      (list 9999
                            ;; TODO: do not hardcode port, and domain
                            (list "example" "www")
                            (list "_" "api" "petit" "cloud")
                            (list)
                            (list)))
                (cons method path))))
     
     (define client-accept
       (lambda (read write close)
         (define-values (method url headers body) (read))
         (if (petit-cloud-deploy? method path)
             (let ((application (make-petit-cloud-application body)))
               (petit-cloud-current-application application)
               (values 201 (list) (bytevector)))
             (let ((application (petit-cloud-current-application)))
               (application method url headers body)))))
                
     (petit-cloud-http-connect "0.0.0.0" 9999 client-accept)

Backtracking

Let’s summarize:

The evaluation of the expression (petit-cloud-http-connect ip port handler) will call HANDLER on each new request. The definition of petit-cloud-http-connect is interesting for the purpose of building a petit cloud, call that the cherry on the cake.
The procedure mentioned above called HANDLER is passed three arguments: read, write, and close.
Each procedure of read, write, and close follow a precise protocol. The way they are applied, its arguments, and return values, but also the order in which each of them is called is specified. For instance, calling close, thereafter read or write does not make sense, because after (close) there is no-one listening.
The procedure petit-cloud deploy will call the procedure HANDLER, compute a new application with make-petit-cloud-application, with the returned procedure, reset the parameter petit-cloud-current-application.

What (make-petit-cloud-application body) do is very interesting. Tho, at this time, that is only food for thought.

Petit Cloud - 2 - Kernel

Wed, 19 Apr 2023 00:00:00 +0000

We jumped into an adventure to build the simplest way possible to deploy a Scheme web application. In the previous article, we identified two procedures, petit-cloud-http-connect, and the kernel procedure make-petit-cloud-application. We will dive into the latter.

Any resemblance to competitor technology is wholly, and fully coincidental.

Continuation

We want to deploy http web application built with a library (hello) with a procedure main:

;; hello.scm
     (library (hello)
       (export main)
       (import (petit-cloud application))
     
       (define main
         (lambda (method path headers body)
           (values 200
                   (list (cons 'content-type "text/plain"))
                   (string->utf8 "Hello schemer!\n")))))

Given an application server running at DOMAIN:PORT, it must be possible to deploy it with the following shell invokation:

#;sh> petit-cloud deploy DOMAIN:PORT hello.scm

Short of logging, monitoring devices, and error handling, the application server code is:

(import (petit-cloud))
     
     
     (define petit-cloud-deploy?
       (lambda (method path)
         ...))
     
     (define client-accept
       (lambda (read write close)
         (define-values (method url headers body) (read))
         (if (petit-cloud-deploy? method path)
             (let ((application (make-petit-cloud-application body)))
               (petit-cloud-current-application application)
               (values 201 (list) (bytevector)))
             (let ((application (petit-cloud-current-application)))
               (application method url headers body)))))
                
     (petit-cloud-http-connect DOMAIN PORT client-accept)

The procedure make-petit-cloud-application takes a bytevector as argument that is read into a symbolic expression that is the same as the library (hello):

;; hello.scm
     (library (hello)
       (export main)
       (import (petit-cloud application))
     
       (define main
         (lambda (method path headers body)
           (values 200
                   (list (cons 'content-type "text/plain"))
                   (string->utf8 "Hello schemer!\n")))))

We want to translate the library (hello) into executable code, in other words convert data into code.

Turning data, into a program can be done with an interpreter.

In the case of Scheme, is to use the readily available eval.¹

Even if they are ways to make it safer, or safe, the procedure eval is unsafe, it can have side effects, and other effects that will have significant security consequences: do not expose such an application server in open Internet without the careful review of an expert.

As of 2023, R7RS specify eval as follow:

(eval expr-or-definition environment-specifier)

The form library is neither an expression, or definition it is in most Scheme implementation a meta-syntaxic device hardcoded in the macro expander, the same component responsible for interpreting macros.

We could rename, and write (hello) on disk, but there is a more straightforward way, a transformation relying on define, set!, and let. The library (hello) can be rewritten into an expression that can be handed to eval to return the procedure main.

The transformation will yield the following expression called module:

(begin
       (define main #f)
     
       (let ()
         
         (set! main
               (lambda (method path headers body)
                 (values 200
                         (list (cons 'content-type "text/plain"))
                         (string->utf8 "Hello schemer!\n")))))
     
       main)

Then, the following snippet, will return main:

(eval module '(petit-cloud application))

That is enough to known to implement a simple make-petit-cloud-application.

Backtracking

We described how to transform an library definition, into an expression that can be fed into eval, that will return the procedure that will eventually reply to end-users.

That is not a complete implementation, more code are necessary to make this outline fit for production. If you want to use such an application server, and self-host it, the code is within reach.

The procedure eval can be implemented as an interpreter, or compiler↩︎

letloop v6

Tue, 04 Jul 2023 00:00:00 +0000

letloop is a Chez Scheme command line tool with some goodies: the test runner with code coverage makes sure you touch the ground running, and it also possible to produce elf binaries for your deployment convenience.

The algorithm to reduce entropy is missing. Be assured that I am doing everything I can to fix the current state of the art^W loop. Meanwhile, download letloop for your favorite GNU/Linux, or (Just Linux), then you can use the following templates as inspiration to invoke your favorite, all around best scheming device:

letloop exec program.scm executes program.scm;
letloop compile program.scm will produce an elf binary called a.out for program.scm;
letloop check library.scm execute the test runner for library.scm. The test runner expects tests to be thunks named with a prefix ~check- e.g. ~check-ess-000-earth-is-not-flat exported by library.scm. The test runner expects a return value that satisfies the following predicate (lambda (x) (eq? x #true), otherwise anything besides #true is considered a test failure, or error, use --fail-fast to exit as soon as bad things happens. A HTML code coverage report with number of run times is produced. It helps identify hot, cold, and dead code.

v6 - let loop be (with small fixes)

letloop offered with the hope of being useable, useful, and used. If you think it fails at one of those, reach me at amirouche@hyper.dev.

This post was sponsored by my grand ma as known as: mother Lily of the valley.

Lily of the valley on top of a mushroom collecting drops of rain from a flower

dx - 0 - cheatsheet on discourse

Sat, 16 Sep 2023 00:00:00 +0000

Screenshot from inanimate alice, perpetual nomads. Available at itch.io.

The three gates of speech

Before you speak, let your words pass through three gates.

At the first gate, ask yourself, is it true.
At the second gate ask, is it necessary.
At the third gate ask, is it kind.

Rogerian rhetoric

You should attempt to re-express your target’s position so clearly, vividly, and fairly that your target says, “Thanks, I wish I’d thought of putting it that way.”

You should list any points of agreement (especially if they are not matters of general or widespread agreement).
You should mention anything you have learned from your target.
Only then are you permitted to say so much as a word of rebuttal or criticism.

Dennett’s version of Rapoport’s Rules

Argument Ranking

●●●●● - High-level generators - Disagreements that remain when everyone understands exactly what’s being argued, and agrees on what all the evidence says, but have vague and hard-to-define reasons for disagreeing.
●●●●○ - Operationalizing - Where both parties understand they’re in a cooperative effort to fix exactly what they’re arguing about.
●●●○○ - Survey of evidence - Not trying to devastate the other person with a mountain of facts and start looking at the studies and arguments on both sides and figuring out what kind of complex picture they paint.
●●●○○ - Disputing definitions - Argument hinges on the meaning of words, or whether something counts as a member of a category or not.
●●○○○ - Single Studies - Better than scattered facts, proving they at least looked into the issue formally.
●●○○○ - Demands for rigor - Attempts to demand that an opposing argument be held to such strict standards that nothing could possibly clear the bar.
●○○○○ - Single Facts- One fact, which admittedly does support their argument, but presented as if it solves the debate in and of itself.
●○○○○ - Gotchas - Short claims that purport to be devastating proof that one side can’t possibly be right.
○○○○○ - Social shaming- A demand for listeners to place someone outside the boundary of whom deserve to be heard.

“How to apologize: Quickly, specifically, sincerely.”, by Kevin Kelly

Arguments category

Ad baculum : Argument relying on an appeal to fear or a threat.
Ad ignorantiam : Argument relying on people’s ignorance.
Ad populum : Argument relying on sentimental weakness.
Ad verecundiam : Argument relying on the the words of an “expert”, or authority.
Ex silentio : Argument relying on ignorance.
Ex nihilo : An argument that bears no relation to the previous topic of discussion.
Non sequitur : An inference that does not follow from established premises or evidence.

Responses

Akrasia : State of acting against one’s better judgment.
Connotation : Emotional association with a word.
Intransigence : Refusal to change one’s views or to agree about something.
Inferential distance : Gap between the background knowledge and epistemology of a person trying to explain an idea, and the background knowledge and epistemology of the person trying to understand it.
Straw man : Creating a false or made up scenario and then attacking it. Painting your opponent with false colors only deflects the purpose of the argument.
Steel man : To steelman is to address the strongest possible variant or the most charitable interpretation of an idea, rather than the most available phrasings.
Red herring : A diversion from the active topic.
Rationalization : Starts from a conclusion, and then works backward to arrive at arguments apparently favouring that conclusion. Rationalization argues for a side already selected.
Dogpiling : A disagreement wherein one person says something wrong or offensive, and a large number of people comment in response to tell them how wrong they are, and continue to disparage the original commenter beyond any reasonable time limit.
Grandstanding : An action that is intended to make people notice and admire you, behaving in a way that makes people pay attention to you instead of thinking about more important matters.
Whataboutism : An attempt to discredit an opponent’s position by charging them with hypocrisy without directly refuting or disproving their argument.
Dissensus : The deliberate avoidance of consensus.

Beliefs

Belief : The mental state in which an individual holds a proposition to be true.
Priors : The beliefs an agent holds regarding a fact, hypothesis or consequence, before being presented with evidence.
Alief : An independent source of emotional reaction which can coexist with a contradictory belief. Example The fear felt when a monster jumps out of the darkness in a scary movie is based on the alief that the monster is about to attack you, even though you believe that it cannot.
Proper belief : Requires observations, gets updated upon encountering new evidence, and provides practical benefit in anticipated experience.
Improper belief : Is a belief that isn’t concerned with describing the territory. Note that the fact that a belief just happens to be true doesn’t mean you’re right to have it. If you buy a lottery ticket, certain that it’s a winning ticket (for no reason), and it happens to be, believing that was still a mistake.
Belief in belief : Where it is difficult to believe a thing, it is often much easier to believe that you ought to believe it. Were you to really believe and not just believe in belief, the consequences of error would be much more severe. When someone makes up excuses in advance, it would seem to require that belief, and belief in belief, have become unsynchronized.
A Priori : Knowledge which we can be sure of without any empirical evidence(evidence from our senses). So, knowledge that you could realize if you were just a mind floating in a void unconnected to a body.

Leading

“A leader is best when people barely know they exists, when their work is done, their aim fulfilled, people will say: we did it ourselves.”

— 老子 (Lao Tse), 道德經 (Dao De Jing)

Wikipedia’s etiquette

The first principle of Wikipedia etiquette has been said to be Assume Good Faith, also they Be Bold, but not Reckless.

Wrong discourse

Answer: Jumping into a conversation with endless unapplicable, unrealistic or unrelated answers to the question.
Question: Spouting accusations while cowardly hiding behind the claim of just asking questions, and ignoring the answers. Asking loaded questions.

Good discourse

Answer: A clear and honest response to the central point of a question without an aggressive attempt to convince.
Question: question asked with the intention to be fair, open, and honest, regardless of the outcome of the interaction.

Social rules are expected to be broken from time to time, in that regard they are different from a code of conduct.

Response Ranking

●●●●●● - Central point - Commit to refute explicitly the central point.
●●●●●○ - Refutation - Argue a conflicting passage, explain why it’s mistaken.
●●●●○○ - Counterargument - Contradict with added reasoning or evidence.
●●●○○○ - Contradiction - State the opposing case, what.
●●○○○○ - Responding to Tone - Responding to the author’s tone, how.
●○○○○○ - Ad Hominem - Attacking the author directly, who.

Interaction Ranking

Discussion

●●●●● - Release - Initiating a discussion on the lessons learnt from a project.
●●●●○ - Update - Presenting the recent development of a personal experience, ongoing event or work in progress.
●●●○○ - Soapbox - Spontaneous and or enthusiastic posts about a general topic of interest or finding.

Low-Effort

●●○○○ - Rant- Venting frustration publicly without explicitly looking to have a conversation about the matter.
●○○○○ - Shitpost - Aggressively or ironically looking for the biggest reaction with the least effort possible. Includes subtoots and vague-posting.

Emotional Reaction

Seduction - You are led to feel that the fulfillment of your dreams depends on your doing what the other is encouraging you to do.
Alignment - The interests of the system are presented as fulfilling your emotional needs. You are led to feel that your survival, your viability in society or your very identity depends on your doing what the other is requiring of you.
Reduction - Complex subjects are reduced to a single, emotionally charged issue.
Polarization - Issues are presented in such a way that you are either right or wrong. You are told that any dialogue between different perspectives is suspect, dangerous or simply not permissible.
Marginalization - You are made to feel that your own interests (or interests that run counter to the interests of the other) are inconsequential.
Framing - The terms of a debate are set so that issues that threaten the system cannot be articulated or discussed. You are led to ignore aspects of the issue that may be vitally important to your own interests but are contrary to the interests of the other that is seeking to make you act in their interests.

Quotes

“Kings speak for the realm, governors for the state, popes for the church. Indeed, the titled, as titled, cannot speak with annyone.” — James P. Carse, Finite and Infinite Games
“Instead of trying to prove your opponent wrong, try to see in what sense he might be right.” — Robert Nozick, Anarchy, State, and Utopia
“You should mention anything you have learned from your target.”
“I don’t argue: I just say what I know or what I believe, as the case may be.” — John W. Cohan

Copy

The whole page is licensed under cc-by-nc-sa; it is adapted from https://wiki.xxiivv.com/site/discourse.html to make it easier for me to change it. I also avoid the words “bad” (replaced with “wrong”) and “faith” (replaced with “discourse”), a few other changes.

dx - 1 - code crafting codex

Sat, 16 Sep 2023 00:00:00 +0000

A problem can have several solutions. A solution can have different implementations each of which with their own strengths and weakness in terms of space, time and generality.

The goal of a code experience design is to optimize the cognitive effort required to understand, learn and use. Otherwise said, code usability aim to improve ease.

While looking for ease, one might trade it over expressive power.

Crafting an experience requires to understand the cognitive load associated with the production. Cognitive load theory has been designed to provide guidelines intended to assist in the presentation of information in a manner that encourages learner activities that optimize intellectual performance.

Here is some of those guidelines:

People learn more effectively when they can build on what they already understand;
Take advantage of schemata;
Take advantage of visual thinking and other non-verbal thought;
The average person can retain ~~only seven~~ five chunks ~~of information~~ in short-term memory;

Repeat!

okvs - 0 - natural query

Sat, 16 Sep 2023 00:00:00 +0000

Ordered Key-Value Store has a small user interface that give us another good good reason to have a look at processing, memory, permanence, and pointer swizzling.

A useable database must offer the following actions:

set will store a piece a data;
query will fetch zero or more piece of data;
~~delete supposed to do what you think it will, but you will not use it, and even when you do, it will just acknowledge you made a wish;~~

The primary question that comes to mind is: what is a piece of data?

In the OKVS paradigm, “piece of data” has two parts: the key, similar to what LISP call car, and the value, similar to what LISP call cdr. So set may be described with set(car, cdr), in more parenthetical terms (set object other)¹. In an OKVS, key, and value, respectively car, and cdr, or object, and other, are sequences of ones and zeros². The user interface of the OKVS paradigm use bit low level data representation.

Data that is binary sequences is a clue into why OKVS is fractal.

We know what is a piece of data: two bit sequences called key, and value. The database is a list of associations between a key, and a value. At any given point in time, given a bit sequence, it can only be associated once, and only once to another bit sequence.

Let’s consider a procedure that would be called get. One must divine that get is a shortcut to (get key) that returns, if any, the value that was associated with key using (set key value).

Comes query.

To be an interesting user interface action, query must subsume get³. The procedure get will read, and return something, if any. The procedure query will also read, and return nothing, return something , and opt-in to return strictly more than one thing. If there is at least two results, one should consider what comes first, what comes next, and if any what comes last... That is why there is an O in OKVS. We want to specify a sorting strategy. The procedure query returns paired bit sequences in their natural order⁴. To cover all use cases, the sorted subspace returned by query is described using two bit sequences called start, and end.

That is why OKVS is fractal.

I tried to avoid a name collision, and by the way the verbatim associate an unexpected sense to the action handle’s surface↩︎
According to astute lispers, it could represent everything, and beyond, of what you take for granted↩︎
In product terms: “describe a feature that is strict superset of what is enabled by get”, in algebraic terms it can be represented by a matrix with a bigger rank, see Scheme. The matrix can describe another space of features, a space where there is more features↩︎
A cyclical, cynical, but not clinical, or poisonous, definition of bit sequence’s natural order↩︎

okvs - 1 - prologue

Sat, 16 Sep 2023 00:00:00 +0000

A better database paradigm is the enemy of good, a perfect database is the enemy of better; on-the-fly mainstreaming commons legacy is future-proof operative.

While there is no shortage of database systems, there used to be none that met my expectations. I can think of the following requirements:

Can write, and read the following structures:
- relational, graphical
- recursive, hierarchical
- time, spatial, geometric
- textual
Support efficient:
- pagination
- versioning
- horizontal scaling
- down scaling
Support ACID transactions across objects
Programmable with Turing-complete programming language

We will argue that one or more of those requirements are unnecessary, and overkill. DWMT. NIH. YAGNI. DRY. We will argue that by relaxing a few of the requirements, a particular software or a set of vendors can bridge the chasm. We will argue endlessly, and we will be building hedera ivy, yet-another-database, wheel re-invention, pollution, the heresy of my diluted genius, that curse the software industry with fragmentation diversity, and fatigue jails. We will mention UNIX, respect, enterprise software architectures, open, free, available, sources, transparent, experiences, know-hows, failures, patterns, bugs, wars, fixes, success, huts, hugs, hubs, stories, productions, uses, re-uses, decades^W centuries^W milleniums of goods, but proof-of-work of maintreaming commons legacy.

Stand up, and still, I boost a grown up trend.

OKVS are used in Software as a Service (SaaS), privateer honeypots, source available software programmed with long now C++, Java, C#, JavaScript, Scala, Go, Zig, Rust, Python, Clojure, Common Lisp, and Scheme.

You have already used an Ordered Key-Value Store.

You know about the components that make an OKVS. If you are a software engineer, you will not learn algorithms, or new structures. You will re-discover how to use, and re-use readily available knowledge to better what you do in a way that is logical, that make sense in your target environment, product, and whatever your varia vocable.

Ordered Key Value Stores are useful, usable, and used.

Is it an expert tool? Is it an acceptable tool? Are problems of yesterday, today, and tomorrow fixed, or some require the precise craft of engineering art?

If the Revised^-1 Report on Kernel is the language of programmable programming; then OKVS is the language of programmable storage.

Caveat emptor: you think in terms of specific, more or less precise, tailored, ad-hoc, prolly re-usable wording. You answer questions such as: what problem do I want to solve? Along the transderivational process, you log the most fitting, under, and over fitting representations; you plan, exercise read, and write workloads, record time, the flow of volatile, and permanent space usage, draft what happens sub-second, shorter than the span of human awareness, and the other side of the continuum: operations that have eventually a long while.

Look to tell a good story.

To ease the reader perfect skills, re-new old ideas, the essence of OKVS paradigm, the reference will also be illustrated with the help of LaTeX to limit, and hopefully eliminate dubious derivations. First, the goal is to cover as much substance as possible to give the freedom to think. Then with convos put the user interface to the test with well-known human interactions.

It helps to give yourself the opportunity to do it, in the most fitting order try to: think, exercise, solve, code, rest, sleep, and have fun.

task - 1 - transderivational beam search

Tue, 19 Sep 2023 00:00:00 +0000

This work was sponsored by enioka.

Given a finite set of objects pool, and an object query. Look, which ever comes first, within approximately t time, or at most n objects subset of pool that are near query according to the metric m, call that subset candidates.

Extra: Add support for continuation. A continuation may produce objects that are more near query than the previous continuation’s candidates.

Transderivational search is a psychological and cybernetics term, meaning when a search is being conducted for a fuzzy match across a broad field. In computing the equivalent function can be performed using content-addressable memory. Unlike usual searches, which look for literal (i.e. exact, logical, or regular expression) matches, a transderivational search is a search for a possible meaning or possible match as part of communication, and without which an incoming communication cannot be made any sense of whatsoever. It is thus an integral part of processing language, and of attaching meaning to communication.

https://en.wikipedia.org/wiki/Transderivational_search

In computer science, beam search is a heuristic search algorithm that explores a graph by expanding the most promising node in a limited set. Beam search is an optimization of best-first search that reduces its memory requirements. Best-first search is a graph search which orders all partial solutions (states) according to some heuristic. But in beam search, only a predetermined number of best partial solutions are kept as candidates. It is thus a greedy algorithm.

https://en.wikipedia.org/wiki/Beam_search

Follow up the exact brute force appraoch

petit-cloud - 3 - be strong hold

Thu, 21 Sep 2023 00:00:00 +0000

petit-cloud is a Scheme application server written in Scheme that makes it easy to deploy web applications. petit-cloud is a single-human sized generation x’s iteration on Earth’s knowledge sharing system; once petit-cloud is ready, set, and serving, an operator can deploy any compatible application from the confort of a wooden chair with one hip command line hop. There is some guess work to do to add support for background task such as database schema changes¹, or sh42ring among manifold operators.

Usage

Server side, you do:

$ ./venv
     $ letloop exec . petit-cloud-server.scm -- 127.0.0.1 9999

Client side, you do:

$ curl http://localhost:9999
     hello world
     $ ./venv
     $ letloop exec . petit-cloud.scm -- http://localhost:9999/_/api/v0/ example.scm
     Please, input the secret: foobar
     Good! What is done, is not to be done!
     $ curl http://localhost:9999
     hello world 1 from example application
     $ curl http://localhost:9999
     hello world 2 from example application
     $

Download

$ wget https://hyper.dev/2023/09/petit-cloud-be-strong-hold/letloop-petit-cloud-v3.tar.gz
     $ sha256sum letloop-petit-cloud-v3.tar.gz
     3c167a09930f812e32a7171e6de1d602654d0715a3d67eb6513554a19ab3913a  letloop-petit-cloud-v3.tar.gz

Visit the repository in letloop organization github.com/letloop/petit-cloud/.

Discussion

What we were talking over the last months^W decades seems within reach when using a tool: Chez Scheme.

Let me invoke the spirit of freedom to say: the fully operational multitenant, lead people generation, multi-party observability, legal checklist, law enforcement, business-as-usual code quality are not only easy, and easier, they are within reach when there is will, food, housing, and psycological security.

when online migration are not supported↩︎

petit-cloud - 4 - f(r)u(c)ture

Thu, 21 Sep 2023 00:00:00 +0000

So far, petit-cloud is a single-human sized clone of generation x’s knowledge sharing system. Once petit-cloud 3 is ready, set, and serving, an operator can deploy any compatible application from the confort of a wooden chair with one hip command line hop. There is some guess work to do to add support for background task such as large database schema changes, or safe support for multiple operators… hyper?

What if we move the operators from each their own chair to the couch?

letloop - 7 - break, the loop

Sat, 30 Sep 2023 00:00:00 +0000

letloop is a Chez Scheme distribution many goodies packed in.

Libraries are embedded in the binary release. It is not using the upstream machinery, it works. You will only need a copy of letloop binary to build a bulletin board about cracking schemers statistically significant cognition patterns with raspberries, and cosmits!

This release improve the software that test, and release letlooop. We are still looking to clone nix, and guix to make letloop a hundred percent linux future-proof. Functional, and in particular functional package management is bootstrapping awesome ideas, tho, that, that is only a good bad rationalization. The good good rationale is that with a nix-like features, letloop will have:

everything in a mono repository, hence waste less energy to be consistent, ordered, and logic;
more independant, and working on upstreaming, and downstreaming.
more control, and easier control over its binary release e.g. make it easier to test, build, then embed .so shared libraries;
reproduciblity;

It is also the test bed of large system such as Earth wanna-be renewable supply chain of joy. If you have ideas, tips, love, and tricks about (just linux) chime in.

We are working on revised ordered key-value store (okvs), and beyond¹. OKVS² has an improved user interface, including more control over memory use, the sample implementation targets permanent storage, and bigger than volatile memory data, built on with entangle async framework. There is manyfold ways, you can help. They are a dozen of extensions (nstore, vnstore, gstore, bbkh, vstore, hnsw…) that should be tested (and reworked :). There is a volatile memory sample implementation; Do not jump head first; introduce your self.

This release comes with the following libraries:

entangle, a transparent asynchronous network library that wrk at 25k RPS; there is code for iouring, but performance are not good; we will investigate having epoll for network, and iouring for disk access.
SRFI 241, match with catamorphism, that makes it very simple to traverse and transform abstract syntax trees;
SRFI 224, integer mappings;
gamma, a predicate generics library;

And more standard tooling:

html;
json;
sxpath;
http;
basic http curl cli bindings;
and some cffi helpers;

Download letloop v7 - break, the loop

letloop is a Chez Scheme distribution with many goodies: the test runner with code coverage makes sure you touch the ground running. letloop can also produce elf binaries for your deployment convenience. The algorithm to reduce entropy is missing. Be assured that we are doing everything we can to fix, and improve the current state of the art^W loop.

We will be there. In the meantime, happy release day!

letloop is offered in the hope of being useable, useful, and used. If you think it fails at one of those, reach me at amirouche@hyper.dev.

What about: Futamura projection + OKVS² = OKVS³↩︎

okvs - 2 - revised okvs interface, alpha release

Fri, 06 Oct 2023 00:00:00 +0000

(import (okvs))

Rework of SRFI-167.

Change log

2023-10-06: initial publication on hyper.dev;

Issues

Missing implementation that rely permanent memory and support bigger-than-memory.

Abstract

Ordered Key-Value Store (OKVS) is a type of data storage paradigm that can support multi-model database. An OKVS is an ordered mapping of bytes to bytes. It is a more powerful paradigm than a key-value store because OKVS allow to build higher level abstractions without the need to do scans. An OKVS will keep the key-value pairs sorted by the key lexicographic order. OKVS systems provides different set of features and performance trade-offs. Most of them are shipped as a library without network interfaces, in order to be embedded in another process. Most OKVS support ACID guarantees. Some OKVS are distributed databases. Ordered Key-Value Store found their way into many modern database systems including NewSQL database systems.

The generics from (okvs) extends the legacy Ordered Key-Value Store interface inherited from Ken Thomson’s DBM, then sleepy cats’ BerkeleyDB, and nowadays FoundationDB, and TiKV to make the implementation of efficient extensions easier thanks to the ability to estimate within a range the count of keys, and the count of bytes.

Rationale

There is several existing databases that expose an interface similar to okvs, and even more that use an Ordered Key-Value Store (OKVS) as their backing storage.

While okvs interface is lower-level than the mainstream SQL, it also has the advantage of having less moving pieces, and stems from a well-known datastructure, part of every software engineering curriculum, namely binary trees, it makes okvs a good teaching material that has immediate useful applications, including building your own SQL database. Last but not least, okvs pin the current practice of building databases on top of a similar tool.

okvs is used to build many datastructures, called extensions.

Extensions of okvs are counter, bag, set, and multi-mapping. Higher level extensions include Entity-Attribute-Value possibly supported by datalog, Generic Tuple Store (nstore) inspired from Resource Description Framework that can match the query capabilities of SPARQL, and RDF-star, or the Versioned Generic Tuple Store (vnstore), that ease the implementation of bitemporal databases. Also, it is possible to implement a property graph database, ranked set, leaderboard, priority queue. It is possible to implement efficient geometric queries with the help of xz-ordered curves. Vector database indices such as Hierarchical Navigable Small World are also available.

Reference

Minimal

`(make-okvs)`

Return a handle over an ordered key-value store.

`(okvs? object)`

Returns #true if object is an ordered key-value store object returned by make-okvs. Otherwise, returns #false.

`(okvs-error? okvs object)`

Returns #true if object is an error produced by okvs. Otherwise, returns #false.

`(okvs-transaction? okvs object)`

Returns #true if object is a transaction object produced by call-with-okvs-transaction or call-with-okvs-transaction-read-only.

`(okvs-handle? okvs object)`

Returns #true if object satisfy one of the following predicate:

okvs-transaction?
okvs-cursor?

`(call-with-okvs-transaction okvs proc success failure)`

Describe the extent of the transaction within PROC in case of success success is called with returned values, when an object is raised failure is invoked with the raised objects. Otherwise, If a continuation escape PROC the behavior is unspecified.

`(okvs-query handle key [other [offset [limit]]])`

If only handle, and key are provided, returns the value associated with key, or #false if key is not paired with an object.

If other is provided, returns a generator producing all pairs present in the okvs associated with handle between key, and other in lexicographic order. If key is smaller than other, the generator produce keys in ascending order, if key is bigger than other produce keys in descending order.

`(okvs-set! handle key value)`

Set, or update the object associated with key to value inside the okvs associated with handle.

The modification is only visible to other transactions when the current transaction returns successfully.

`(okvs-clear! handle key [other])`

Clear the pairing, if any, that key has with an object inside the okvs associated with handle.

The modification is only visible to other transactions when the current transaction returns successfully.

`(okvs-close okvs)`

Close the database okvs.

Base

`(okvs-empty? handle)`

Returns #true if the database associated with a handle that is empty. Otherwise, returns #false.

`(call-with-okvs-transaction-read-only okvs proc success failure)`

`(okvs-key-max-size handle)`

Returns the maximum size of a key for the database associated with HANDLE.

`(okvs-value-max-size handle)`

Returns the maximum size of a value of the database associated with HANDLE.

`(okvs-cursor? okvs object)`

Returns #true if object is a cursor object produced by call-with-okvs-cursor.

`(make-okvs-parameter default)`

Returns a procedure that is a parameter bound during the extent of transactions. transaction parameters follow the protocol:

When a transaction parameter is called with one argument that satisfies okvs-transaction?, it returns the current value associated within the ongoing transaction, that is default at the beginning of the transaction, and until the transaction parameter is reset.
When a transaction parameter is called with two arguments, the first must satisfy the predicate okvs-transaction?, the second argument can be anything; that will reset the object associated with the transaction parameter within the ongoing transaction. An immediate call with the same transaction object as only argument.

Calling a transaction parameter outside a transaction is an error.

`(okvs-parameterize ((okvs-parameter object) ...) body ...)`

Binds okvs-parameter ... to object ... while evaluating body ...

`(okvs-begin-hook okvs)`

Returns the SRFI-172 hooks associated with okvs. The begin hook’s procedures are called, when a transaction is started, at the beginning of the transaction, inside the transaction.

`(okvs-pre-commit-hook okvs)`

Returns the SRFI-172 hooks associated with okvs. The pre-commit hook’s procedures are called, at the end of a transaction, before call-with-okvs-transaction or call-with-okvs-transaction-read-only returns, inside the transaction.

`(okvs-post-commit-hook okvs)`

Returns the SRFI-172 hooks associated with okvs. The post-commit hook’s procedures are called, at the end of a transaction, before call-with-okvs-transaction or call-with-okvs-transaction-read-only returns, outside the transaction, after the transaction has succeed to commit.

`(okvs-rollback-hook okvs)`

Returns the SRFI-172 hooks associated with okvs. The rollback hook’s procedures are called, at the end of a transaction, before call-with-okvs-transaction or call-with-okvs-transaction-read-only exit, outside the transaction, after the transaction has failed to commit.

`(okvs-approximate-key-count handle [key other])`

Returns an approximate count of keys inside the okvs associated with handle.

`(okvs-approximate-byte-count handle [key other])`

Returns an approximate count of bytes inside the okvs associated with handle.

`(call-with-okvs-cursor handle key proc)`

`(okvs-next cursor)`

Try to move cursor to the next pairing. If there is a lexicographically a bigger key in the okvs, returns #true. Otherwise, returns #false. It means the cursor is at the end of the key space, and okvs-key or okvs-value will return #false.

`(okvs-previous cursor)`

Try to move cursor to the previous pairing. If there is a lexicographically a smaller key in the okvs, returns #true. Otherwise, returns #false. It means the cursor is at the beginning of the key space, and okvs-key or okvs-value will return #false.

`(okvs-key cursor)`

Returns the key associated with cursor. Returns #false when cursor is at the beginning, or the end of the key space, or when the cursor is not set.

`(okvs-value cursor)`

Returns the value associated with cursor. Returns #false when cursor is at the beginning, or the end of the key space, or when the cursor is not set.

seed - 0 - freedom of expression, and the spirit of John Shutt’s Kernel

Fri, 13 Oct 2023 00:00:00 +0000

Picture from instagram via midjourney.

If you find Scheme boring, without creativity, and dare challenge without fear the gentle, hot and firm burn of minimalism^W barely understood devices such as procedural pattern matching, gamma, vau, and statistics gathered on-the-fly to configure lowering at runtime that may be wholly, and fully localized, user defined, packaged, and re-used¹.

Even if those are readily source available by your favorite brute force army. There is a parenthetical take: Kernel, and Futamura. Read on.

Kernel is the other programming interface that I can not take my mind away from. I tried. I failed. I failed many times. I failed Babelia because Kernel. I worked hard. I failed. I still dare recalling my failure. And nowadays, I do not shy away anymore. I dare claim it is not only elegant, it is beautiful. It takes more head space than any other language, standard, or (parenthetical leaning) implementation. It seems to me there is enough material for one to beam gamma rays to alphas for inspiration for decades, maybe centuries!

The primo, and ultimo goal: control a little more than Sun core.

Big Equation

Previously I called the following John Shutt’s equation of software. To keep any error my own, and because it goes against the grain, I intend to not mention him outside reference, and thanks. May his arguments always be properly evaluated.

The purpose of that equation is to describe enough of a system, and deliver enough material to support engineered discourse. Here are the three branches of seed’s eval:

(define (eval xp env ctx)
       (cond
        ;; If the expression `XP` is a symbol, return the object that is
        ;; associated with it in the environement `ENV`...
        ((symbol? xp) (environment-ref env xp))
        ;; If `XP` is a construction, try to apply it
        ((pair? xp)
         (define combiner (let ((prefix (car xp)))
                            (if (combiner? prefix)
                                prefix
                                (environment-ref env prefix))))
         (cond ;; Most likely combiner class, what is returned by lambda
          ((applicative? combiner)
           ;; Evaluate arguments `(cdr XP)`, hopfully mere environement-ref.
           (let ((xp+ (map (lambda (x) (eval x env ctx)) (cdr xp))))
             (apply combiner env ctx xp+)))
          ((operative? combiner)
           ;; The arguments `(cdr XP)` are passed as is, most likely, but
           ;; not only: symbols, numbers, booleans, and constructions...
           (apply combiner env ctx (cdr xp))))
         ;; ... not only self-evaluating!
         (else xp)))

The variable ctx hold the current flow of execution, to make it possible to migrate across hardware frontiers.

Small Demo

Download the small demo at hyper.dev.

Glimpsing over

Combiners returned by vau make it possible, and easy to hook into compilation machinery, that is without more time spent on a wood bank.

`when`

Here is the when:

(define when
       (vau (object . xps) env
           (if (eval object env)
               (eval (list* sequence xps) env)
               (void))))

Mind the fact that it works better if you do not know what a macro is, what compilation hooks are, and when you are not parenthetical phobic. Some familiarity with Scheme standard, R4RS, or R5RS helps.

It can be used like:

(when signal
       (reply 2006))

At somepoint, the previous procedure definition of when will be called. Using beta-reduction, and the fact that only signal, and replay are lexically scoped:

(if (eval 'signal env)
         (eval (list* sequence (list 'reply 2006)) env)
         (void)

Only object, xps were copy-pasted as a construction, and self-evaluating objects like symbols. In env, the symbols 'signal, and 'reply are bound. When (eval 'signal env) is processed, it returns for instance 101. That yields the following sequence:

(if 101 ;; that is not flasy
         (eval (list* sequence (list 'reply 2006)) env)
         (void)

Then:

(eval (list* sequence (list 'reply 2006)) env)

That is evaluated at call-site to the same object as the following expression:

(reply 2006)

Anaphoric When

Anaphoric when will bind the condition, called object in the above definition, to a variable inside the body. That is similar to walrus operator. An anaphoric when can be implemented with:

(define anaphoric-when
       (vau (variable object . xps) env
         (define tmp (eval object env))
         (if tmp
             (eval (list* sequence xps)
                   (environment-cons env (list (cons variable tmp))))
             (void))))

It is supposed to be used in cases where the test condition is cpu heavy:

(anaphoric-when signal (+ 2006 (- 1337 42))
             (reply signal))

Similar to when, the use of anaphoric when is mostly lexically scoped. The applicative eval takes an environment as argument. The definition of anaphoric-when needs the object associated with the symbol object when anaphoric-when is used, hence the first line (define tmp (eval object env)) where ENV is the environment where anaphoric-when is used.

The main difference between when and anaphoric-when is that anaphoric adds the condition object inside the environment where the body of anaphoric-when is evaluated.

Again, describing a beta-reduction sequence:

(define tmp (eval (list '+ 2006 (list '- 1337 42)) env))
     (if tmp
         (eval (list* sequence (list 'reply 'signal))
               (environment-cons env (list (cons 'signal tmp))))
         (void))

(define tmp 3301)
     (if tmp
         (eval (list* sequence (list 'reply 'signal))
               (environment-cons env (list (cons 'signal tmp))))
         (void))

(if 3301 ;; not falsy
         (eval (list* sequence (list 'reply 'signal))
               (environment-cons env (list (cons 'signal 3301))))
         (void))

(eval (list* sequence (list 'reply 'signal))
           (environment-cons env (list (cons 'signal 3301))))

The previous s-expression will be evaluated at call-site to the same object as:

(reply 3301)

That is echo.

Why

Unlike define-macro, and even more so hygienic syntax transformers, the approach of f-expr using vau makes it possible to re-use existing knowledge of how to program. It may be possible to re-implement the industrial macro machinery of modern implementations, but do we really want that?

Conclusion

I will write a procedural match ie. a pattern matcher, then see where to go from there. I think publicly distributed, and localized code are more helpful, than any other projections.

By the way, while I am at looking forward, take a look at GRASP, The GRAphical Scheme Programming Environment, look at the videos. I also recommend the answers by the same author on quora.

Regarding Futamura projection, it appears it is still interesting, and good material to build a new implementation of Scheme. After reading pebook, it is certain that it is a lot of work.

may be known as up-coming long awaited next AAA release.↩︎

Racket’s Chez merged into Cisco’s Chez

Sat, 21 Oct 2023 00:00:00 +0000

A very well come merge of Racket’s Chez into Cisco brings many interesting features. It already available with the following command line dance:

git clone --filter=blob:none https://github.com/cisco/chezscheme
     cd chezscheme
     ./configure --installprefix=$HOME/.local/
     make -j $(nproc --ignore=1)
     make install

I am very interested in the following new features:

Hardware support includes AArch64 for Linux, Mac OS, and iOS, and RISC-V;
Unboxed floating points operations;
The new operator thread-join;
Safe procedure fasl-read;

For full release notes look at:

https://users.cs.utah.edu/~mflatt/tmp/release_notes_v999.html

Or the up-to-date:

https://github.com/cisco/ChezScheme/blob/main/release_notes/release_notes.stex

task - 1 - exact brute force rank

Mon, 13 Nov 2023 00:00:00 +0000

This work was sponsored by enioka.

The task one is:

Given a finite set of objects pool, and an object query. Look, which ever comes first, within approximately t time, or at most n objects subset of pool that are near query according to the metric m, call that subset candidates.

Most popular approach nowadays, and the one I could start to get under control is to rely on Hierarchical Navigable Small Worlds. HNSW is reminiscent of Ben Goertzel glocals from opencog fame.

HNSW datastructure use a deterministic heuristic with the distance function to construct clusters, still, it use random to spread pression on memory, and compute. It looks like a skip-list with multiple path ways. A regular natural sort will not speed queries, because of that glocals are not sorted, instead nodes are related to points in a higher level layer. The higher the level the less points they are. The highest level has only one point. Each point has a maximum x neighbor in a lower level. Horizontal navigation must be done through the parent point.

While I put that whole on a flashcard, you can delice with the following brute force algorithm that will generate a pool of points nearest to a point query:

(import (chezscheme))
     (import (letloop r999))
     (import (scheme generator))
     
     ;; brute force algorithm
     
     (define total (string->number (or (getenv "HYPER_TOTAL") "65536")))
     (define exponent (string->number (or (getenv "HYPER_EXPONENT") "8")))
     
     (define pk
       (lambda args
         (write args)
         (newline)
         (car (reverse args))))
     
     (define point-distance
       (lambda (a b) (abs (- a b))))
     
     (define point-random (lambda () (random (expt 2 exponent))))
     
     (define pool (map (lambda _ (point-random)) (iota total)))
     (define query (point-random))
     
     (define ~.two
       (lambda (x)
         (inexact (/ (round (* x 100)) 100))))
     
     (define candidates
       (let* ((objects (map (lambda (x) (cons (point-distance query x) x)) pool))
              (objects* (sort (lambda (u v) (< (car u) (car v))) objects))
              (distance-max (apply max (map car objects*))))
         (map (lambda (x) (cons (~.two (/ (- distance-max (car x)) distance-max))
                                (cdr x)))
              objects*)))
     
     (pk 'query (string-upcase (number->string query 36)) query)
     (newline)
     (for-each pk (map (lambda (x) (list (car x) (number->string (cdr x) 36) (cdr x))) candidates))

hyper.dev

Cross-compiling Racket’s Chez

Petit Cloud - 0 - Specification

Specification

Petit Cloud - 1 - Kickstart

Continuation

Backtracking

Petit Cloud - 2 - Kernel

Continuation

Backtracking

letloop v6

dx - 0 - cheatsheet on discourse

Do not share, what you do not want to be known

The three gates of speech

Rogerian rhetoric

Argument Ranking

Arguments category

Responses

Beliefs

Leading

Wikipedia’s etiquette

Wrong discourse

Good discourse

Response Ranking

Interaction Ranking

Discussion

Low-Effort

Emotional Reaction

Quotes

Copy

dx - 1 - code crafting codex

okvs - 0 - natural query

okvs - 1 - prologue

task - 1 - transderivational beam search

petit-cloud - 3 - be strong hold

Usage

Download

Discussion

petit-cloud - 4 - f(r)u(c)ture

letloop - 7 - break, the loop

okvs - 2 - revised okvs interface, alpha release

(import (okvs))

Change log

Issues

Abstract

Rationale

Reference

Minimal

(make-okvs)

(okvs? object)

(okvs-error? okvs object)

(okvs-transaction? okvs object)

(okvs-handle? okvs object)

(call-with-okvs-transaction okvs proc success failure)

(okvs-query handle key [other [offset [limit]]])

(okvs-set! handle key value)

(okvs-clear! handle key [other])

(okvs-close okvs)

Base

(okvs-empty? handle)

(call-with-okvs-transaction-read-only okvs proc success failure)

(okvs-key-max-size handle)

(okvs-value-max-size handle)

(okvs-cursor? okvs object)

(make-okvs-parameter default)

(okvs-parameterize ((okvs-parameter object) ...) body ...)

(okvs-begin-hook okvs)

(okvs-pre-commit-hook okvs)

(okvs-post-commit-hook okvs)

(okvs-rollback-hook okvs)

(okvs-approximate-key-count handle [key other])

(okvs-approximate-byte-count handle [key other])

(call-with-okvs-cursor handle key proc)

(okvs-next cursor)

(okvs-previous cursor)

(okvs-key cursor)

(okvs-value cursor)

seed - 0 - freedom of expression, and the spirit of John Shutt’s Kernel

Big Equation

Small Demo

`(make-okvs)`

`(okvs? object)`

`(okvs-error? okvs object)`

`(okvs-transaction? okvs object)`

`(okvs-handle? okvs object)`

`(call-with-okvs-transaction okvs proc success failure)`

`(okvs-query handle key [other [offset [limit]]])`

`(okvs-set! handle key value)`

`(okvs-clear! handle key [other])`

`(okvs-close okvs)`

`(okvs-empty? handle)`

`(call-with-okvs-transaction-read-only okvs proc success failure)`

`(okvs-key-max-size handle)`

`(okvs-value-max-size handle)`

`(okvs-cursor? okvs object)`

`(make-okvs-parameter default)`

`(okvs-parameterize ((okvs-parameter object) ...) body ...)`

`(okvs-begin-hook okvs)`

`(okvs-pre-commit-hook okvs)`

`(okvs-post-commit-hook okvs)`

`(okvs-rollback-hook okvs)`

`(okvs-approximate-key-count handle [key other])`

`(okvs-approximate-byte-count handle [key other])`

`(call-with-okvs-cursor handle key proc)`

`(okvs-next cursor)`

`(okvs-previous cursor)`

`(okvs-key cursor)`

`(okvs-value cursor)`

`when`