• implemented in dat/dot.lisp

lisp/ffi/

https://github.com/facebook/rocksdb/wiki/Compaction-Filter

(rocksdb-compactionfilterfactory-create nil (alien-sap (alien-callable-function 'rocksdb-destructor))
                                        (alien-sap (alien-callable-function 'rocksdb-create-compaction-filter-never))
                                        (alien-sap (alien-callable-function 'rocksdb-name)))

• need to figure out what delete-value requires
  • simply passes state + value and value-length to a function
  • when the value is null it doesn't exist in db (noop) ?
  • unclear when the merge op actually runs in relation to deletion op - before or after?
• https://docs.rs/rocks/latest/rocks/merge_operator/index.html

• define macro which eases the process of making custom merge operators

(define-merge-operator :incf nil
  :full nil
  :partial nil)
(create-incf-mergeoperator)

#<SB-ALIEN-INTERNALS:ALIEN-VALUE :SAP #X75D288000C30 :TYPE (*
                                                            (SB-ALIEN:STRUCT
                                                             ROCKSDB::ROCKSDB-MERGEOPERATOR-T))>

• document in Commentary section
• also consider https://github.com/antirez/linenoise
• RLWRAP settings for SBCL · GitHub
• CIEL Is an Extended Lisp
• GitHub - sharplispers/linedit: Readline-style line-editor for Common Lisp.

with skel taking on more responsibility we no longer need a dedicated build tool.

• migrate all functionality to skelfile
• cleanup readme with installation instructions (with and without infra)
• easy to break the skel binary and overwrite a LKG version, preventing future builds.
  • just be more careful
  • sanity checks
  • repurpose x.lisp to recover from situations like these specifically

• do not need to handle multiple commands
  • what do we want to do about subcommands?
• do not need to support 'global' option for commands
• use cli-parse to test.

• multiple entrypoint lisp images
• create multiple links to core lisp image
• support multiple low-level methods?
  • naive implementation is a single entry point with a switch dispatched on arg0.
  • could also create a thin shim in Rust/Zig and call the appropriate entrypoint after loading the core.
• for now let's put this in lib/cli so that we can use defmain

• finish implementation

• need new command or flag for rules
• evaluate forms instead of looking in skelfile

• remove package-inferred
• minimize number of systems
• use pkg.lisp files

• a bit too large, time to shake it up
• need separation of concerns (files) for task-pool/threaded tests in particular

• refer to cffi and uffi
• cffi/src/types.lisp at 32c90d4a9a01e809f591276c058e5b3c7f39b154 · cffi/cffi · GitHub

• mostly just need the tests and to finish porting the Franz implementation

• ported from XDB2

• list of links between other headings
  • <= links to this item
  • => links from this item
  • == siblings
  • ^= parent
  • v= child
• how should it look when exported?
• org-graph-link-use-timestamp
• org-graph-link properties? edge properties?
  • keyvals :key val - should probably align with whatever we use for CONSTRAINTS, for now read as sxp
• EXPORT_EDGES property?

* example
:PROPERTIES:
:ID:       id1
:CUSTOM_ID: demo
:END:
:EDGES:
<- bar
[2024-09-14 Sat 22:37] <- bar
[2024-09-14 Sat 22:50] :key val :foo (bar baz) <- bar
[2024-09-14 Sat 22:37] -> foo
[2024-09-14 Sat 22:39] -- sibling
[2024-09-14 Sat 22:39] >> parent
[2024-09-14 Sat 22:39] << child
:END:

• follow LOCATION property of heading at point
• respect parent LOCATION, buffer local settings, etc

similar to org-set-effort, to be called automatically on capture.

• should prompt for directory then file - skip file with C-u or with RET
  • simpler to just prompt for value with completion using org-read-property-value

homepage 'symlink farm manager' rust impl: https://github.com/qboileau/rstow

rocksdb/slicetransform.lisp

• consider use cases in Lisp images - pre-loading and coordinating shared fasls and core images
• no longer maintained by intel

A Gentle Introduction to XDP | Datadog GitHub - xdp-project/xdp-tools: Utilities and example programs for use with XDP

• xdp-paper/xdp-the-express-data-path.pdf at main · xdp-project/xdp-paper · GitHub
• BPF and XDP Reference Guide — Cilium 1.18.0-dev documentation
• will require linking to libbpf and libxdp, needs elf loader (or use xdp-tools/iproute2)
• blocked by bpf impl in lisp

Home - DPDK GitHub - DPDK/dpdk: Data Plane Development Kit

By leveraging DPDK libraries, developers can create optimized packet processing paths, manage timers for executing functions asynchronously, and utilize a wide range of drivers and libraries tailored for fast packet processing.

librte_eal – Environment Abstraction Layer: Provides the foundational API for DPDK, facilitating access to hardware resources such as memory, timers, and logs.

librte_mempool – Memory Pool Manager: Manages memory pools for efficient and speedy packet handling.

librte_ring – Ring Buffer Manager: Implements lock-free FIFO queues, enabling high-speed communication between various DPDK components.

librte_mbuf – Packet Buffer Management: Handles packet buffers, which are crucial for packet transmission and reception.

librte_ethdev – Ethernet Device API: Offers an API for configuring and querying Ethernet devices. It supports various operations, including sending and receiving packets.

librte_net – Network Helper Library: Provides helper APIs for dealing with network protocols.

librte_ipfrag – IP Fragmentation and Reassembly: Handles fragmentation and reassembly of IP packets, supporting both IPv4 and IPv6.

librte_kni – Kernel Network Interface: Facilitates communication between DPDK applications and the Linux kernel networking stack, primarily used for debugging or interfacing with existing Linux network services.

https://docs.kernel.org/bpf/standardization/instruction-set.html#bpf-instruction-set-architecture-isa https://mostlynerdless.de/blog/2023/12/31/hello-ebpf-developing-ebpf-apps-in-java-1/ https://github.com/iovisor/bcc GitHub - mikeroyal/eBPF-Guide bpftrace/tools/README.md at master · bpftrace/bpftrace · GitHub

• bpftrace seems quite powerful, will be useful for sysmon activities

where would ebpf support go?

probably io.. but maybe also log, net.. syn?

Doc-overview - batman-adv - Open Mesh

Not that useful in our current environment (NIH)

lapack.h is massive and impractical to attempt lisp bindings from scratch.

instead, our current approach is based on tree-sitter:

(tree-sitter:load-tree-sitter)
(tree-sitter:load-tree-sitter-alien)
(tree-sitter:load-tree-sitter-c)

#P"/usr/local/lib/libtree-sitter-c.so"

(syn/ts::ts-file-query :c #p"/usr/include/openblas/lapack.h" "(declaration)")

#<SB-ALIEN-INTERNALS:ALIEN-VALUE :SAP #X71384C005800 :TYPE (*
                                                            (SB-ALIEN:STRUCT
                                                             TREE-SITTER:TS-QUERY-CURSOR))>

this segfaults:

(in-package :syn/ts)
(sb-alien:with-alien ((m (* tree-sitter::ts-query-match) (sb-alien:make-alien tree-sitter::ts-query-match)))
  (sb-sys::with-pinned-objects (m)
    (tree-sitter::ts-query-cursor-next-match
     (syn/ts::ts-file-query :c #p"/usr/include/openblas/lapack.h" "(declaration)") m)))

(let ((tree (flatten (syn/ts::parse-file :c #p"/usr/include/openblas/lapack.h")))
      (dx 0)
      (ret))
  (loop with dx = 0
    for di = (print (position :declaration tree :start dx))
    if (null di) 
    do (return ret)
    else
    do (progn
         (setf dx (incf di))
         (let ((ei (print (position :declaration tree :start dx))))
           (push (subseq tree di ei) ret)))))

(setq 
 *lapack*
 (let* ((str (read-file #p"/usr/include/openblas/lapack.h"))
    (tree (flatten (syn/ts::parse-string :c str :consume t :produce-cst nil)))
    (dx 0)
    (ret))
   (setq *lapack.h* str)
   (loop with dx = 0
     for di = (position :declaration tree :start dx)
     if (null di) 
     do (return ret)
     else
     do (progn
          (setf dx di)
          (incf dx)
          (let ((ei (position :declaration tree :start dx)))
        (push (subseq tree di ei) ret))))))
(list (length *lapack*) (length *lapack.h*))

(labels ((lastr (x start end)
           (apply 'subseq *lapack.h* (subseq x start end)))
         (lasym (str) (symbolicate (string-upcase (substitute #\- #\_ str))))
         (lasym* (str)
           (let ((len (length str)))
             (list '* (lasym (subseq str 0 
                                     (if (char= (char str (1- len)) #\*)
                                         (1- len)
                                         len))))))
     (lasyms (x start end)
       (symbolicate (string-upcase (substitute #\- #\_ (lastr x start end)))))
     (laparm (str)
       (let ((a (nreverse (split-sequence #\space str))))
         (list (if (string-equal (first a) "T")
                       (gensym "T")
                       (lasym (first a)))
           (if (third a)
                       ;; type param (could be X const* or const X*)
                       (if (string-equal (third a) "const")
                           (lasym* (second a))
                           (lasym* (third a)))
                       (when (second a)
             (lasym* (second a)))))))
         (gen-lapack-args (p x)
           (let* ((pa (position :parameter-list x)) ;; param start
              (pb (position :preproc-ifdef x)) ;; param end
              (params (subseq x pa pb)))
         (loop with p1 = 0
               for pos = (position :parameter-declaration params :start p1)
               while pos
               do (setf p1 (1+ pos))
               collect (laparm (lastr params (+ pos 1) (+ pos 3)))))))
  (setq *code*
    (mapcar
     (lambda (x)
       (let ((p (position :function-declarator x)))
         (list* 'deflapack
            ;; routine name
            (lasyms x (+ p 5) (+ p 7))
            ;; return-type
            (lasyms x (- p 3) (- p 1))
            ;; list of function parameters (NAME TYPE)
            (remove-if (lambda (x) (eql (car x) 'fortran-strlen)) (gen-lapack-args p x)))))
     *lapack*)))
(length *code*)

1332

(with-output-to-file (f file) 
  (write-line ";;; lapack-ffi.lisp --- LAPACK Alien Routines -*- buffer-read-only:t -*-" f)
  (write-line "(in-package :lapack)" f)
  (mapc (lambda (x) (write x :stream f :case :downcase) (terpri f)) *code*))

currently segfaults - should be easy to fix

the toml parser on quicklisp is based on esrap, make a comparable one using our parser module.

• core/rule.lisp

Control stack exhausted (no more space for function call frames).
This is probably due to heavily nested or infinitely recursive function
calls, or a tail call that SBCL cannot or has not optimized away.

PROCEED WITH CAUTION.
   [Condition of type SB-KERNEL::CONTROL-STACK-EXHAUSTED]

 849: ((:METHOD SB-PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SB-PCL::SLOT-CLASS T)) #<STANDARD-CLASS OBJ/QUERY:LOGICAL-QUERY-PLAN> (#<STANDARD-DIRECT-SLOT-DEFINITION OBJ/AST:AST> #<STANDARD-DIRECT-SL..
      Locals:
	SB-PCL::ALLOCATION = :INSTANCE
	SB-PCL::ALLOCATION-CLASS = #<STANDARD-CLASS OBJ/QUERY:LOGICAL-QUERY-PLAN>
	SB-PCL::ALLOCP = T
	CLASS = #<STANDARD-CLASS OBJ/QUERY:LOGICAL-QUERY-PLAN>
	SB-PCL::DIRECT-SLOTDS = (#<STANDARD-DIRECT-SLOT-DEFINITION OBJ/AST:AST> #<STANDARD-DIRECT-SLOT-DEFINITION OBJ/AST:AST> #<STANDARD-DIRECT-SLOT-DEFINITION OBJ/AST:AST>)
	DOCUMENTATION = NIL
	SB-PCL::DOCUMENTATIONP = NIL
	SB-PCL::INITARGS = (:AST)
	SB-PCL::INITFORM = NIL
	SB-PCL::INITFUNCTION = NIL
	SB-PCL::INITP = NIL
	SB-PCL::NAME = OBJ/AST:AST
	SB-PCL::NAMEP = T

 855: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<FUNCTION (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-PCL::UPDATE-CLASS) {739064260D1B}> #<MUTEX "PCL global mutex" taken owner=main thread>)
      Locals:
	GOT-IT = NIL
	MUTEX = #<MUTEX "PCL global mutex" taken owner=main thread>
	SB-C::THING = #<FUNCTION (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-PCL::UPDATE-CLASS) {739064260D1B}>

• things lib/math will need from obj:
  • plan
  • store
  • graph
  • srv?
  • schema?
• may go to std

• Common Lisp Statistics · GitHub
• GitHub - Lisp-Stat/lisp-stat: Lisp-Stat main system
• GitHub - takagi/cl-cuda: Cl-cuda is a library to use NVIDIA CUDA in Common Lisp programs.
• GitHub - quil-lang/magicl: Matrix Algebra proGrams In Common Lisp.
• SRFI 231: Intervals and Generalized Arrays
• lisplab
• matlisp
• and next.. pola.rs
• use 3d-math patches as a way to learn more about what we will need
• we need a lot more than just matrix acceleration.
• llvm-project/mlir/docs/Dialects/Linalg/_index.md · JuliaLang/llvm-project
• LAPACK? ye probably - be aware of symbol rewrites caused by FC
  • solved in blas (wip)

• What is the difference between Tensors and Matrices? · Learn Tensorflow

  A matrix is a two-dimensional grid of size n×m that contains numbers: you can add and subtract matrices of the same size, multiply one matrix with another as long as the sizes are compatible((n×m)×(m×p)=n×p)((n×m)×(m×p)=n×p), and multiply an entire matrix by a constant.

  A vector is a matrix with just one row or column (but see below), vector has direction, but tensor has no direction.

  A tensor is often thought of as a generalized matrix. That is, it could be

  a 1-D matrix, like a vector, which is actually such a tensor, a 3-D matrix (something like a cube of numbers), a 0-D matrix (a single number), or a higher dimensional structure that is harder to visualize. The dimension of the tensor is called its rank.

  Any rank-2 tensor can be represented as a matrix, but not every matrix is really a rank-2 tensor. The numerical values of a tensor’s matrix representation depend on what transformation rules have been applied to the entire system.

• obj should NOT depend on math
  • math depends on obj for tensor
• accumulators? hmm..
  • need to be in math but also used by queries which is in obj
  • may need to split out obj/query to Q
    • done
  • moved to std/seq
• math depends on ffi, depended on by dsp,net,apps,etc
• should probably have the most tests of all libs
• we want OBJ/TENSOR - see tensor

delete unbound non-anaphoric symbols

(let ((ret))
  (do-external-symbols (s :std ret)
    (when (not (or (boundp s) (fboundp s) (cadr (multiple-value-list (typexpand s))) (find-class s nil)))
      (push s ret))))

We were doing some things right - like our semaphore worker waking

• already added this to BROADCAST-WORK (comment suggestion by lmj)
• mailbox stuff not as useful (speed is a concern over more primitive cas queues and spinlocks)

• generic done
• maybe simple version in std/fmt

• generic done

• convenience for defining alien structs, especially with the same name as lisp type

• [2026-01-13 Tue]

  ; compilation unit finished
  ; RDB::CURSOR-GET-BOTH-BUFFERED
        RDB::CURSOR-MOVE-BUFFERED RDB::CURSOR-SET-BUFFERED
        RDB::DB-CURSOR RDB::DB-CURSOR-MOVE-BUFFERED
        RDB::DB-CURSOR-PGET-BOTH-BUFFERED RDB::DB-CURSOR-PMOVE-BUFFERED
        RDB::DB-CURSOR-PSET-BUFFERED RDB::DB-CURSOR-SET-BUFFERED
        RDB::DB-DELETE-BUFFERED RDB::DB-PUT-BUFFERED
        GETRF! GETRI! GETRS!
        OBJ/STORE::INSTANCE-CLASS-INDEX OBJ/STORE::INSTANCE-TABLE
  

• no AWS_LC
• vanilla openssl (vendored)

STYLE-WARNING:
   Couldn't grovel for SSL_OP_IGNORE_UNEXPECTED_EOF (unknown to the C compiler).
STYLE-WARNING: Couldn't grovel for SSL_OP_NO_SSLv1 (unknown to the C compiler).
STYLE-WARNING:
   Couldn't grovel for SSL_OP_NO_SSLv1_1 (unknown to the C compiler).
STYLE-WARNING:
   Couldn't grovel for SSL_OP_NO_SSLv1_2 (unknown to the C compiler).
STYLE-WARNING:
   Couldn't grovel for SSL_CTRL_SET_MIN_PROTO_VERSION (unknown to the C compiler).
STYLE-WARNING:
   Couldn't grovel for SSL_CTRL_SET_MAX_PROTO_VERSION (unknown to the C compiler).

generalize to all linux includes

• prob keep uring separate

• move scripts to top-level

[BROKEN LINK: No match for fuzzy expression: ;; FIX 2025-06-10: why can't we find compile-system even when specifying the package?] std/defpkg:symbol-call :asdf "COMPILE-SYSTEM"

(documentation (find-class 'cli-command) t)

Class of COMMANDs which may be executed directly from the command line.

(documentation 'define-cli 'function)

Define a new CLI object.

NAME is assigned to the CLI and assumed to be the default binary name which
uses this object.

VERSION, DESCRIPTION, HOOK, CD, and MAIN are assigned to the associated slot
value of the CLI.

(directory-files-recursively "~/src/core/" ".*cli[.]lisp$")

• ~/src/core/app/mpk/cli.lisp
• ~/src/core/app/skel/homer/cli.lisp
• ~/src/core/app/skel/krypt/cli.lisp
• ~/src/core/app/skel/packy/cli.lisp
• ~/src/core/app/skel/cli.lisp
• ~/src/core/lib/cli/cli.lisp
• ~/src/core/lib/organ/cli.lisp
• ~/src/core/lib/pod/cli.lisp
• ~/src/core/lib/rdb/cli.lisp
• ~/src/core/lib/syn/cli.lisp
• ~/src/core/lib/vc/cli.lisp

should be pretty simple - bind C-x to a command which calls read-chord and looks up the next funcall in a user-specified command table.

• replace with serialize/deserialize

• this should give us enough to remove the remaining C code from the core source tree
• replace zstd/alien.c and tree-sitter/alien.c with C gen-syntax.
• next we will target full header files
  • REW_MODE

• commands are a more generalized concept than we initially planned
  • CLI is most used case (depth), WM contains most commands (breadth)
• cli-cmd -> cli-command
• obj:defcommand (obj:defcmd?)
• obj:*command-table*
• our preference is to store them as funcallable objects (kernels)
• NOPE: do we need a package? probably want to access via symbol-table -> compile functions

we need to ignore lambda-list-keywords, apply interactive spec

• do we want a 'skip' interactive designator? probably not

(defcommand foo (&optional bar) (declare (interactive string))) ; FIXED

• ☑ CHECK-ITYPE should only be called in DEFCOMMAND
• ☑ after parse-command we need to compare the arglist to ITYPE
  • skip all provided args
  • call the remaining interactive-types with INPUT

• MATLISP uses a somewhat janky macro-based template approach
  • compiles methods in place.. (defmethod foo () (compile-and-eval `(defmethod %foo ...)) (%foo))
  • mention in the comments of using MOP instead
• instead of macro-based templates let's abuse compiler macros as much as we can
• ☐ investigate tensor methods
• instead of compiler macros, let's abuse the compiler :)
  • deftransform, array specialization stuff (sb-vm, sb-c)
• sbcl has its own concept of higher-ordered types see define-type-class
• MATLISP main branch uses MOP - tensor-class and tensor-method-generator, in addition to the auto-memoized templates (std/meta for us)
  • [2025-11-20 Thu] currently transitioning to this API
  • attempting to leverage STD:KERNEL-CLASS for the tensor accessor stuff. Could be a bad idea.. TBD.

• FOR-MOD clause
• file:///home/ellis/.stash/scratch/matlisp-git/src/base/boolean.lisp - usage
• also bool.lisp
• technically possible with sbcl internals, but likely very difficult
• to not get stuck in implementation we should have a workaround solution

• still something suspicious going on, computed method isn't being dispatched correctly

(handler-case (obj/tensor::ref (obj/tensor::zeros 100) 0)
    (error (c) (print c)))

#<TYPE-ERROR expected-type: ARRAY
             datum:
             #<OBJ/TENSOR::|<BLAS-MIXIN SIMPLE-DENSE-TENSOR: DOUBLE-FLOAT>| {120DB56EE3}>> 

• one of the filters isn't doing the right thing in the presence of standard method defs (generic defs)

• entry-weights are sorta broken
• need to re-evaluate based on CACLE and probably add some missing slots - policy can't be abused the way we're doin it.

• base16

Base16 aims to group similar language constructs with a single color. For example, floats, ints, and doubles would belong to the same colour group. The colors for the default theme were chosen to be easily separable, but scheme designers should pick whichever colours they desire, e.g. base0B (green by default) could be replaced with red. There are, however, some general guidelines below that stipulate which base0B should be used to highlight each construct when designing templates for editors.

Since describing syntax highlighting can be tricky, please see base16-vim and base16-textmate for reference. Though it should be noted that each editor will have some discrepancies due the fact that editors generally have different syntax highlighting engines.

Colors base00 to base07 are typically variations of a shade and run from darkest to lightest. These colors are used for foreground and background, status bars, line highlighting and such. Colors base08 to base0F are typically individual colors used for types, operators, names and variables. In order to create a dark theme, colors base00 to base07 should span from dark to light. For a light theme, these colours should span from light to dark.

we want to resuse the internal sbcl machinery as much as possible to avoid making copies of string coders.

babel provides a flexible charset coding library similar to libiconv. The semantics are somewhat different from SBCL but they share basically the same goal.

It appears that babel ENCODINGs are used in many places where a simple sbcl EXTERNAL-FORMAT would do. The difference is that EXTERNAL-FORMATs are not supposed to be extensible (AFAIK). Babel seems to make the assumption that we aren't supposed to mess with sb-impl and other internals much - which is where all the useful stuff is.

I have a hunch there is some reason other than portability that its so prevelant tho.. only one way to find out :)

(rgrep "babel" "*.*" "~/src/core/lib/net/")

• babel-encodings
  • enc-max-units-per-char
  • lookup-mapping
  • string-vector-mappings
  • code-point-counter
  • decoder

;; defined in sb external format def macros
(defun ,(make-od-name ',octets-to-string-name/cr accessor) (array astart aend replacement)
  (declare (optimize speed)
           (type ,type array)
           (type array-range astart aend)
           (ignorable replacement))
  (let ((string (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t)))
    (loop for apos from astart below aend
          do (let* ((byte (,accessor array apos))
                    (code (,',->code-name byte))
                    (string-content
                      (cond
                        ((null code)
                         (decoding-error array apos (1+ apos)
                                         '(,',external-format :newline :cr)
                                         replacement
                                         ',',decoding-condition-name
                                         apos))
                        ((= code 13) (code-char 10))
                        (t (code-char code)))))
               (if (characterp string-content)
                   (vector-push-extend string-content string)
                   (loop for c across string-content
                         do (vector-push-extend c string))))
          finally (return (coerce string 'simple-string))))))

• uses deflate
• refactor salza2 to use io protos
• replace salza2 and remove dependency

• use compress and decompress instead - no direct stream support

• keep getting segfaults when using the streaming api (which is much faster and needed for serious use)
• need to debug and fix, test in dat/tar on tar.zst files

• make-sparse-keymap
• probably just using hash-tables, same as color palettes, etc.
• how should we handle transients?
• what is the relation with commands?
  • wm already binds the last keyseq for each command
  • would want to bind a *KEYMAP* variable with a STATE slot being the active parent key

• erased on read
• might want to indicate working-dir, output

• translate between simple-strings and cstrings (special case of string)

• in prim.lisp
• shared macro for defining the follow interfaces:
  • readtables (would need additional refactoring to depend on prim.lisp)
  • print tables
  • annotations
  • commands
  • thread-pools
  • colors
  • keybinds
  • loop universes?
  • io-table?

• at least have option of disabling - it isn't always correct about the location

• core/vm.lisp
• how will rules, commands, and components interact?
  • what sort of configuration is needed and where?
• requires load, building of logical plan, execution of physical plan (in async runtime) with results (+cache)
• analysis pre/post-load, pre/post execution
• execution strategies?
• main thread should show progress in parallel
  • capture conditions/debugger
  • figure out how to retrieve stacktrace from worker threads

• we broke sk-file-component, need to repair

default.el:176:7: Warning: assignment to free variable ‘multisession-storage’
default.el:184:11: Warning: assignment to free variable ‘hg-binary’
default.el:240:6: Warning: docstring has wrong usage of unescaped single
    quotes (use \=' or different quoting such as `...')
default.el:259:30: Warning: ‘:inherit’ called as a function
default.el:260:30: Warning: ‘:indentation’ called as a function
default.el:261:42: Warning: reference to free variable ‘defpackage’
default.el:262:31: Warning: ‘define-package’ called with 1 argument, but
    requires 2 or more
default.el:262:31: Warning: ‘define-package’ is an obsolete function (as of
    29.1).
default.el:286:9: Warning: assignment to free variable
    ‘common-lisp-style-default’
default.el:305:19: Warning: reference to free variable ‘eglot-server-programs’
default.el:305:19: Warning: assignment to free variable
    ‘eglot-server-programs’
default.el:313:7: Warning: assignment to free variable ‘rust-rustfmt-switches’
default.el:314:7: Warning: assignment to free variable ‘rust-indent-offset’
default.el:317:7: Warning: assignment to free variable ‘python-indent-offset’
default.el:321:7: Warning: assignment to free variable ‘js-indent-level’
default.el:324:7: Warning: assignment to free variable ‘sh-basic-offset’
default.el:331:12: Warning: in defcustom for ‘prog-comment-keywords’: missing
    :type keyword parameter
default.el:336:12: Warning: in defcustom for
    ‘prog-comment-timestamp-format-concise’: missing :type keyword parameter
default.el:342:12: Warning: in defcustom for
    ‘prog-comment-timestamp-format-verbose’: missing :type keyword parameter

In prog-comment-timestamp-keyword:
default.el:386:2: Warning: docstring has wrong usage of unescaped single
    quotes (use \=' or different quoting such as `...')
default.el:414:20: Warning: reference to free variable
    ‘comment-timestamp-format-verbose’
default.el:443:7: Warning: assignment to free variable ‘hexl-bits’

In buffer-to-register:
default.el:474:47: Warning: Unused lexical argument ‘delete’

In file-to-register:
default.el:481:45: Warning: Unused lexical argument ‘delete’

In file-query-to-register:
default.el:487:51: Warning: Unused lexical argument ‘delete’
default.el:529:12: Warning: in defcustom for ‘default-scratch-buffer-mode’:
    missing :type keyword parameter
default.el:625:7: Warning: assignment to free variable
    ‘eshell-highlight-prompt’
default.el:626:7: Warning: assignment to free variable
    ‘eshell-hist-ignoredups’
default.el:627:7: Warning: assignment to free variable
    ‘eshell-save-history-on-exit’
default.el:629:7: Warning: assignment to free variable
    ‘eshell-destroy-buffer-when-process-dies’

In eshell-quit-or-delete-char:
default.el:645:20: Warning: ‘looking-back’ called with 1 argument, but
    requires 2 or 3
default.el:645:33: Warning: reference to free variable ‘eshell-prompt-regexp’
default.el:650:6: Warning: ‘delete-forward-char’ is for interactive use only;
    use ‘delete-char’ instead.
default.el:654:29: Warning: reference to free variable ‘eshell-mode-map’

In eshell-next-prompt:
default.el:660:22: Warning: reference to free variable ‘eshell-prompt-regexp’
default.el:661:9: Warning: reference to free variable
    ‘eshell-highlight-prompt’

In eshell-insert-history:
default.el:677:48: Warning: reference to free variable ‘eshell-history-ring’
default.el:736:49: Warning: reference to free variable ‘eww-mode-map’
default.el:747:7: Warning: assignment to free variable
    ‘org-id-link-to-org-use-id’
default.el:749:7: Warning: assignment to free variable ‘org-capture-templates’
default.el:761:7: Warning: assignment to free variable
    ‘org-html-htmlize-output-type’
default.el:762:7: Warning: assignment to free variable
    ‘org-html-head-include-default-style’
default.el:764:7: Warning: assignment to free variable ‘org-ascii-text-width’
default.el:768:7: Warning: assignment to free variable
    ‘org-structure-template-alist’
default.el:805:7: Warning: assignment to free variable ‘org-archive-location’

In org-ask-location:
default.el:853:11: Warning: Unused lexical variable ‘org-refile-targets’
default.el:856:28: Warning: reference to free variable ‘org-refile-history’
default.el:860:18: Warning: reference to free variable
    ‘org-complex-heading-regexp-format’

In org-capture-fileref-snippet:
default.el:868:37: Warning: Unused lexical argument ‘f’
default.el:906:7: Warning: assignment to free variable ‘org-global-properties’

In org-adjust-tags-column-reset-tags:
default.el:936:39: Warning: Unused lexical argument ‘ignored’

In column-display-value-transformer:
default.el:942:55: Warning: Unused lexical argument ‘value’
default.el:954:7: Warning: assignment to free variable
    ‘org-columns-modify-value-for-display-function’

In org-remove-redundant-tags:
default.el:974:32: Warning: Unused lexical variable ‘tag’
default.el:984:69: Warning: ‘memql’ called with literal list that may never
    match (arg 1)

In org-agenda-reschedule-to-today:
default.el:995:35: Warning: Unused lexical argument ‘rest’
default.el:999:2: Warning: ‘defadvice’ is an obsolete macro (as of 30.1); use
    ‘advice-add’ or ‘define-advice’

In org-export-translate-to-lang:
default.el:1079:35: Warning: reference to free variable
    ‘org-export-dictionary’

In end of data:
default.el:979:42: Warning: the function ‘org-toggle-tag’ might not be defined
    at runtime.
default.el:971:8: Warning: the function ‘org-map-entries’ might not be defined
    at runtime.
default.el:961:4: Warning: the function ‘org-table-map-tables’ might not be
    defined at runtime.
default.el:949:9: Warning: the function ‘org-entry-end-position’ might not be
    defined at runtime.
default.el:946:8: Warning: the function ‘org-back-to-heading’ might not be
    defined at runtime.
default.el:937:20: Warning: the function ‘org-set-tags’ might not be defined
    at runtime.
default.el:918:10: Warning: the function ‘org-set-property’ might not be
    defined at runtime.
default.el:916:14: Warning: the function ‘org-entry-get-multivalued-property’
    might not be defined at runtime.
default.el:912:12: Warning: the function ‘org-entry-get’ might not be defined
    at runtime.
default.el:898:23: Warning: the function ‘which-function’ is not known to be
    defined.
default.el:858:6: Warning: the function ‘outline-next-heading’ might not be
    defined at runtime.
default.el:855:24: Warning: the function ‘org-refile-get-location’ might not
    be defined at runtime.
default.el:846:39: Warning: the function ‘org-todo’ might not be defined at
    runtime.
default.el:843:48: Warning: the function ‘org-read-date’ might not be defined
    at runtime.
default.el:843:23: Warning: the function ‘org-time-string-to-time’ might not
    be defined at runtime.
default.el:664:4: Warning: the function ‘eshell-skip-prompt’ is not known to
    be defined.
default.el:647:10: Warning: the function ‘eshell-life-is-too-much’ is not
    known to be defined.
default.el:641:6: Warning: the function ‘eshell-send-input’ is not known to be
    defined.
default.el:633:14: Warning: the function ‘eshell/alias’ is not known to be
    defined.
default.el:308:6: Warning: the function ‘eglot-x-setup’ is not known to be
    defined.
default.el:261:39: Warning: the function ‘as’ is not known to be defined.
default.el:261:31: Warning: the function ‘defpkg’ is not known to be defined.
default.el:260:30: Warning: the function ‘:indentation’ is not known to be
    defined.
default.el:259:30: Warning: the function ‘:inherit’ is not known to be
    defined.
default.el:258:4: Warning: the function ‘define-common-lisp-style’ is not
    known to be defined.
default.el:245:8: Warning: the function ‘slime-eval-async’ might not be
    defined at runtime.
default.el:243:14: Warning: the function ‘slime-sexp-at-point’ might not be
    defined at runtime.
default.el:241:13: Warning: the function ‘slime-read-from-minibuffer’ might
    not be defined at runtime.
default.el:233:10: Warning: the function ‘slime-repl’ is not known to be
    defined.
default.el:228:14: Warning: the function ‘slime-connected-p’ might not be
    defined at runtime.
Loading which-key (native compiled elisp)...done
All your packages are already installed
Waiting for git... [2 times]
Loading /home/ellis/.emacs.d/ellis.el (source)...
Local variables list is not properly terminated
Source file ‘/home/ellis/.emacs.d/lib/ulang.el’ newer than byte-compiled file; using older file
Initialized ULANG.
Repeat mode is enabled for 38 commands and 13 keymaps; see ‘describe-repeat-maps’
Loading /home/ellis/.emacs.d/ellis.el (source)...done
Starting Emacs daemon.

should extensively support throughout our code

• in desperate need of cleanup, simplification, and documentation.
• what can we learn from doom?
• make outline: core:man#Emacs
• use-package#Top
• later: eglot-tempel

• ☑ pod
• ☑ box
• ☑ .hgsub

• ☑ collect artifacts
• ☑ pack
• ☑ send output to DIST
• ☑ Adapt to skel deploy
• assumptions
  • host is qualified builder
  • all dependendencies installed on system (not in stash)
  • current user has access to DIST
• done in org skelfile

• done in org skelfile
• ☑ load dependencies (htmlize,default.el,babel.org)
• ☑ load publish.el
• ☑ set publish-directory
• ☑ eval publish

• pull-tree-sitter-langs.sh
• install-tree-sitter-langs.sh (OG, calls pull)
• make dist/tree-sitter

skel is high-level enough that we don't need the sk- prefix - where possible we should take advantage of the STD/SYS protocol too - in particular components, which might need to be added to the PROJECT protocol.

• useful for fonts, see help:customize-face
• RT or DOC?
• maybe NLP.. - refactored to syn
• see emacs-lorem-ipsum
• https://loremipsum.io/

• catch up on current state, qemu may be enough but we need single-click dispatch to interactive login
• interested in VNC
• use NET for network configs
• patch into skel/comp/box
  • consider separate classes and removing the :type requirement.. .box or .qemu vs .archiso, meh

• iolib/src/base/return-star.lisp
• nested block returns
• following macros are redefined in iolib/base:
  • defun
  • defmethod
  • lambda*
  • defmacro
  • define-compiler-macro
• all wrap body in wrap-body-for-return-star

• macrolets return*:

  (cl:defun wrap-body-for-return-star (body &optional block-name)
    (flet ((block-name (block)
             (etypecase block
               (cons (destructuring-bind (kind block-name) block
                       (assert (eql 'setf kind))
                       (check-type block-name symbol)
                       block-name))
               (symbol block))))
      (multiple-value-bind (body declarations docstring)
          (parse-body body :documentation t)
        (with-gensyms (value)
          (remove-if
           #'null
           `(,docstring
             ,@declarations
             ,(if block-name
                  `(macrolet ((return* (,value) `(return-from ,',(block-name block-name) ,,value)))
                     ,@body)
                  (with-gensyms (block)
                    `(block ,block
                       (macrolet ((return* (value) `(return-from ,',block ,value)))
                         ,@body))))))))))
  

• idk do we really need this anywhere? let's see..
• determination: NOPE
• effectively this just shortens a return-from statement, just worth keeping in mind while reading iolib code - return* != return.

• ulang?
• emacs#Change Log
• add-log.el
• HG vc backend does not support ChangeLog 😢

• the emacs client part is relatively simple

(add-to-list 'eglot-server-programs '(lisp-mode "skel" "lsp"))

• hard part is JSON-RPC + LSP on top of swank
• eglot has a soft dependency of markdown-mode, yasnippet and company
• intention is to replace eglot--snippet-expansion-fn eglot--format-markup

• eglot#Top
• eglot-format
• integrates with flymake
• integrates with yasnippet (prob need to impl for abbrevs/tempo/skel)

Most Eglot facilities are integrated into Emacs features, such as ElDoc, Flymake, Xref, and Imenu. However, Eglot also provides commands of its own, mainly to perform tasks by the language server, such as ‘M-x eglot-rename’ (to rename an identifier across the entire project), ‘M-x eglot-format’ (to reformat and reindent code), and some others. *Note Eglot Commands::, for the detailed list of Eglot commands.

• eglot-semantic-faces - presentations?

• Org-mode Workflow Part 1: Capturing in the Inbox · Jethro Kuan
• Org-mode Workflow Part 2: Processing the Inbox · Jethro Kuan

• inbox capture

  `("i" "inbox" entry (file ,org-inbox-file) :prepend t)
  

• project capture
• task capture
• habit capture
• log capture

• a few defined in ellis.el
• define some starter ones for inbox.el
• define views for plan.el

• project-local skel shell
• features based on skelfile/cli? (swank, lsp)

• don't open desktop when any args are passed
• emacs OK
• emacs foo NO
• later.. emacs skelfile should be dynamic - enable desktop based on project config

• need to set the desktop-save-buffer value for the following buffers:
• slime,ielm,eshell,org-agenda,notmuch,elfeed
• see desktop-buffer-mode-handlers and desktop-minor-mode-handlers
  • dired-restore-desktop-buffer

(add-to-list 'desktop-buffer-mode-handlers '(skel-mode . skel-restore-desktop-buffer))
(add-to-list 'desktop-minor-mode-handlers '(skel-minor-mode . skel-restore-desktop-buffer))

• also requires setting up misc-data..
• better off leaving as is for now.
• eventually we may want to store a checksum which gets passed to the server on project start/desktop open and determines if reparse is needed
• better example: eww-desktop-misc-data
• (setq-local desktop-save-buffer #'eww-desktop-misc-data)

Only the properties listed in ‘eww-desktop-data-save’ are included. Generally, the list should not include the (usually overly large) :dom, :source and :text properties.

(:url :title :point)

• tags are a synonym for identifier reference
• see https://www.gnu.org/software/emacs/manual/html_node/emacs/Tags-Tables.html
• maybe useful as a 'catchall' term capture thing, use in skel shell, etc. otherwise not too concerned with it.

• hunspell dictionary defaults to $HOME - figure out how to remap, pre-populate, and import into public dictionary (dict.compiler.company)

(fasls)

• [2025-05-01 Thu 21:02] Discord Lisp#common-lisp

  so I've been thinking about logical pathnames for a bit - it appears
  there is plenty of room for implementation-defined extension in the
  spec (via translate-logical-pathname keyword args) as well as
  load-logical-pathname-translations - what I'd like to do is make some
  recommendations for extending the capabilities in a
  backwards-compatible way that are less geared towards managing
  filesystem conventions between different physical hosts and more
  towards being an easy 'path-finding' tool which is easy for
  programmers to plug custom logic into.
  
  @phoe would this be something a CDR would apply to? alternatively I
  could just work on a patch to submit for sbcl - still need to look at
  if any other impl does something fancy
  

Bike: honestly that's the only thing i use them for, but i'm open to
suggestions. what would you like to have beyond the
logical-pathname-translations interface?

[10:26 PM]ellis: what I'm thinking is some sort of API where you can
provide additional layers of translation, maybe by specifying a
keyword argument args in the form :translate-device (lambda (device)
;; translation? side effects on dynamic vars?) :translate-version..

[10:31 PM]ellis: for load-logical-pathname-translations i like the
idea of a similar situation with a user defined function instead of
relying on 'SYS:SITE;HOST.TRANSLATIONS' - maybe I want to use this in
a p2p discovery service for example and I want to specify a function
which does a remote lookup, parses a response and returns the
appropriate form

[10:33 PM]ellis: right now i'm just experimenting with the
conventional local-projects approach, stuff like 'SYS:TMP' and
'MEDIA:MUSIC', which has kept me busy enough but will find some time
to prototype something out

[10:40 PM]ellis: a few other things that came to mind..  cached/db
access to pathname translation index-based wildcard translation
(sketchy) - (translate-logical-pathname "MEDIA:MUSIC;0"
:translate-wildcard (lambda (x) (aref
*sorted-music-directory-contents* x)))

[10:44 PM]ellis: really makes more sense as a package, like
translate-pathname* but just a shame to waste those keyword args lol

[10:44 PM]ellis: (defvar *default-logical-pathname-translator* 'translate-logical-pathname)

• [2025-05-02 Fri 14:57] initial feedback

  3:48 AM]Isomorphism: Yeah but on the other hand, why not just make a
  dedicated library to your path parsing thing? Generic extensions to
  path resolution is a little scary to me, given that something
  unrelated could suddenly become vulnerable to some injection attack
  
  [9:51 AM]Bike: i would generally be skeptical of a global hook like
  this translator. it's nasty if libraries can rebind or set a variable
  and suddenly logical pathname stuff everywhere breaks, including
  inside the implementation. logical-pathname-translations is sorta
  there already though
  

• 3d Math
• Shinmera/3d-math
• Shinmera/verbose
• Shinmera/piping
• https://github.com/Shirakumo/manifolds
• https://github.com/Shirakumo/redist
• https://github.com/Shirakumo/layout
• https://github.com/Shirakumo/lichat-protocol
• https://github.com/Shirakumo/l-hacd
• https://github.com/Shirakumo/hourly

• to move forward with purpose we need a clear charter
• audience: semi-technical (knows what python and git is, has used an IDE)
• the art of programming
  • treating machines as extensions of ourselves, our minds and ideas
  • understanding machines as a means of understanding the world, understanding ourselves
  • expression of ourselves - digital traversal of mediums
  • programming as a skill
    • high skill-ceiling
    • skill-multiplier: programmers benefit the most from technological advances
    • programming knowledge has high utility
      • transferrable across domains/langs/systems
    • IDE, domain knowledge, learning system
  • programming as a science
    • expression is important to scientists too
      • math notation
      • algorithm development
    • modeling/simulation/forecasting
    • search and sort
    • multi-disciplinary utility
      • eliminates boundaries (DRY), more knowledge sharing
    • cellular automata
  • needs protecting
    • (LLMs, cite code quality, state of C++, Hare/Zig/Nim, frameworks, js ecosystem, malicious companies)
    • client/server arch, cloud, SaaS, subscription model, browsers, right to repair, limiting access to energy, data, bandwidth
  • how?
    • if you can't beat them…
      • Do It Yourself
    • eliminate dependencies
    • encourage extension
    • process, time
    • Lisp/Macros/Compilers
• re-inventing the Lisp Machine
  • history, MIT->Symbolics->LMI->TI/Xerox->AI Winter
  • image-based software
  • vs other, why it failed
  • eliminating dependence on specialized hardware
• exploring modern computability
  • 'mixed' systems - highly distributed systems with human operators
  • explainability, introspection, etc
  • finding the 'happy path' on target machines
  • make every device possible 'well-behaved'
  • highly deterministic, highly interactive
• designing robust systems and toolchains
  • targeting a 'fleet' of machines/devices/nodes
    • home
    • office
    • lab
    • vehicle
  • modular p2p protocols, schedulers, services
  • small worker nodes, large service nodes, REPL access anywhere

• systemize services
• extend db
• define API
• init UI

• contact management for data hoarders/hackers
• use wide variety of techniques to disambiguate PII
• pattern detection and analysis

• full mpd replication/compat
• complete gstreamer FFI bindings
• basic db schema
• basic file management
• UI design requirements
• torrent/ytdl service layer

• design requirements only
• local ML engine, LLM, compute-bias
• container image/VM
• c2, not-in-scope: p2p

io_uring is the Linux library we have chosen to spend some time getting comfortable with and for which we've written incomplete Common Lisp bindings - URING. This library will soon be developed in parallel to the higher-level IO library - similar to the development of ROCKSDB and RDB.

Over the next few months our IO ecosystem will slowly expand. As a short-term goal, we will implement simple binary streams backed by io_uring.

The pieces are there, just needs glue.

A usable SKEL system is a top priority for this year. To get there we need to give love to many of the underlying core libraries too - most of all cli.

The two top priorities are VC commands and implementing a functional replacement for makefiles as used in the infra project.

• similar idea to org-roam
• stored in rocksdb columns

It is time to move away from makefiles and start integrating our own programs into the system bootstrap process. This iteration of the infra project will have a few POSIX shell scripts for checking the host and grabbing a pre-compiled lisp as well as a compressed infra.core image.