Core Tasks

• may need to do a C wrapper, do some research first to make sure we didn't miss something in impl.

• a few from each level
• benchmarks

• should have a very clean interface with io/static
• make sure to bench vs using plain sb-sys:with-pinned-objects

• need some basic error handling which indicates an error thrown from C.

• ☐ sudo example (filesystem)
• ☐ non-sudo example?

• sub-proto of doc
• generate api documentation for project X in Y format
• maybe just publish?

• starting with tempo files
• keep in lib/doc
• do we need definition templates?
• definition types:
  • function (setf)
    • macro
  • variable (constant,special)
  • type
  • class
  • struct
  • condition
    • restart
  • GF (setf, class, method-combos)
    • method
• (readtable alien-callable optimize type structure variable method-combination compiler-macro setf function)

• clap is quite unstable right now and has some obvious bugs which need remedying

• should have same result, define WITHOUT-TTY-ECHO

• repl config? yes

• pronounced 'Dee-qwul'
• the challenge it seems, is building an inference engine that isn't just another half-assed prolog
• expression and introspection is valued here much more than speed/size
• allegro and screamer are favorites so far

• kquery

• object-based protocol for asking questions about data collections using data expressions
• lex, parse, compile - all handled in the Q system
• probably in need of refactor right after
  • different parts of the protocol will be used by different systems
    • data-source will be implemented in DAT/CSV DAT/PARQUET, RDB, etc
    • query-expression and query-plan will be implemented in Q/SQL and Q/DQL

add tests for lexer and LALR. figure out if there are any gaps that we need to fill.

(org-element-parse-buffer)

(describe sxp)

#<OBJ/AST:AST {1215B0A143}>
  [standard-object]

Slots with :INSTANCE allocation:
  AST                            = NIL

• time for trees
• recursively parse headlines and store them in AST slots
• sections (ORG-CONTENTS) contain everything upto the next heading or EOF

• need to unwrap the pointer (* (* t))
• cast to string,int,bool
• wrap segfault handlers
• add restarts for common errors (bad path)
• add cleanup routines

• clients are fully dynamic
• generated from RDB instances
• compiles in CF/option/multithread/type info
• clients implement custom Q language

• use SBCL built-ins to extend the api - wrap the raw FFI iterator
• define mixins

• supply custom comparators to rocksdb from lisp

• capture types of: kv, cf
• specs
  • kv-spec = (kv-spec val-spec)
    • must be serialized to/from vec<char>
  • cf-spec
    • used as superclass
    • methods for abstracting CFs

• need better api
• may just want to use the generic C fn that takes string as input
• I feel this may be less efficient but haven't benched it (requires additional arg)
• separate packages are a pain to query symbols with

• may want a generalized interface that also supports with/without cf, timestamp, etc

was getting hung up on why there is no 'open-cf' based on name in the C api really - the 'rocksdb-open-column-families' function is somewhat misleading.

database - Is there a way to retrieve `ColumnFamilyHandle` from `ColumnFamilyName` in RocksDb? - Stack Overflow

ultimately there is no way to do this - when opening the database you can specify which CFs to be opened and a new cf-handle is always returned on creation.

We should NOT use create- when there are existing columns that we just want to get a SAP for. Instead always opt for opening a new db instance, possibly by closing an existing one.

RDB::CURSOR-GET-BOTH-BUFFERED RDB::CURSOR-MOVE-BUFFERED
RDB::CURSOR-SET-BUFFERED RDB::DB-CURSOR RDB::DB-CURSOR-DELETE
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-DELETE-KV-BUFFERED RDB::DB-GET-KEY-BUFFERED
RDB::DB-PUT-BUFFERED RDB::DUP-BTREES RDB::INDEX-TABLE-ASSOC
RDB::KEY-FN RDB::PRIMARY

see graph node github.com

• a function which accepts a single arg which is either a number, indicating index-based selection or a list of column names for selection by name.

(read-csv-line ... :select (lambda (x) x))

• index-based-selection
• selection-by-name

• bluelisp/zip
• leverages deflate, similar structure to tar (can we share API?)
• generator for with macro - should use same protocol - define in obj somewhere

• sxp is back on the menu
• serializable format supporting as many objects as possible
• first implementation of complete STORE protocol
• act as human/machine-readable db format

• cl-emb and cl-template use <% %>
• would prefer #% %#

• green impl of SB-GROVEL
• no dependency on ASDF
• no constants.lisp
  • use lookup functions to retrieve forms
• directly integrates with SYS
• depends on C and Tree-sitter C bindings
• does NOT execute compiled C, simply uses the C compiler for macro expansion and parses with SYN/TS, spits out Lisp forms (probably depend on STD/ALIEN).
• unsure on the caching strategy
  • where should the compiled output go? we probably want to keep some accounting info in the fsys, forms in a fasl (invisible to user)
  • avoid reparsing when C files are unmodified
  • avoid regen when Lisp AND C files are unmodified
• do we need an incremental update feature? where forms are user-maintained, and we emit conditions when a user-specified version goes out of sync..
  • we might need this to specify the :IN :OUT parameters in DEFINE-ALIEN-ROUTINE arguments - don't think those can be determined programatically but TBD

• make a script

• get this working and tested, implement for org-graph
• keep working our way up the chain to stored-object-schemas

• may want to ditch the init protocol and use DEFINE-COMMAND-TABLE
• consider PARENT:CMD protocol (modify parse/read)
• if command not found in primary check parent
• we now may need more than hash-tables..

• mix of config/val/cmd protocols
• first use of color output
• defcustom
• customize, customize-group, etc

• completion-at-point functions for lisp types
• insert arbitrary objects and get a list of completions to be used by input
• metadata/marginalia extensions?

• use xmlrep as much as possible
  • should cover xspam
  • publishing might need a macro or two

• implement simple network fixtures which can be used within the body of DEFTEST
• start with simple sockets - UDP then TCP
• work up towards HTTP

• MTU discovery handled via cli
• don't care too much about multicast discovery
• set via variables
• multicast range: 224.0.0.0:239.255.255.255
  • base address: 224.0.0.0
  • all hosts: 224.0.0.1
  • all routers: 224.0.0.2
  • OSPF: 224.0.0.5
  • IGMP: 224.0.0.22
  • RIP: ..9
  • PTP: ..107

• needs a solid task-pool impl completed first
  • pending std/defsys

prevent tests from printing implicitly. redirect stream locally, cache it somehow for review.

• simple flag to test when file is defined (part of deftest macro)

root test directory /tmp/rt with subdir for each suite, initialize from within suite

• likely to be kernel-objects
• use DEFAPI (pending DEFAPI)

• kernel-objects

IS macros aren't reporting their failures correctly - should be returning conditions which bubble up to the caller.

• multiplexer implementation based on iolib
• default to epoll
• impl for dbus
• impl for wm
• (maybe back up select/poll)
• then uring

• ☑ parse keyboard definitions from simple strings
• ☐ parse keyboard definitions from lists
• KEY
• KEYMAP
• IO
  • READ-KEY
  • WRITE-KEY
  • READ-KEY-SEQ
  • WRITE-KEY-SEQ
• PRINT-KEY
• KBD
• SERDE :XLIB
• DEFINE-KEY
• DEFINE-KEYMAP

• we probably do want something similar to flexi-streams after all
• need condition handling for external-formats and list/vector streams
• hook them in to io/fast and io/static
• tensor streams
• columns

(for j in-vector (δ-i g) from li below ri)

• expand into LOOP OR
• maybe we should do VIDX loop-path after all

• CLHS: System Class BROADCAST-STREAM

• db can only have single writer
• wbwi + commit
• better condition handling when db already opened (read rocksdb error codes? i know we have the strings..)
• also nice to have blobdb logs
  • individual log files living in same directory, only one write needed
  • still doesn't necessarily prevent deadlocks, just much harder to trigger

use on lisp and rust side, makefiles, etc.

• nushell uses NU_LOG_LEVEL - can we override?

• ie C-c g w pre-populate with name of node, maybe thing-at-point with C-u

• index based? inherit from parent only for now
  • how to implement for complete tree?
  • custom_id for edges? like @ref bibtex

The update behavior on mouse hover is quite nice - let's enable that for keyboard-based navigation too.

• toggled on with F, but doesn't follow timeline blocks
• should follow block on hover or when cursor is inside a block
• same applies for timeline selection

• there's some timeline-specific properties, let's integrate those with our standard properties
• TIMELINE_FACE = COLOR?
• TIMELINE_TEXT = SUMMARY
• TIMELINE_GROUP = GROUP or CATEGORY
• TIMELINE_DO_NOT_OVERLAP

• sorta already works.. probably just need to add a hook for updating list of dirs with project dirs.

• ideally have a function that overlays a skelfile/sxp buffer with a customization interface
• need to maintain mapping between buffer forms and widgets

emacs#Directory Variables

Lisp Indent (GNU Emacs Manual) Brain dump – Custom Common Lisp indentation in Emacs

• project-compile-directory
• skel-recompile

• :defer, :ensure