wfn

It’s already happening on 50c14L.com

You mention "end to end encrypted comms", where to you see end to end there? Does not seem end to end at all, and given that it's very much centralized, this provides... opportunities. Simon's fatal trifecta security-wise but on steroids.

https://50c14l.com/docs => interesting, uh, open endpoints:

- https://50c14l.com/view ; /admin nothing much, requires auth (whose...) if implemented at all

- https://50c14l.com/log , log2, log3 (same data different UI, from quick glance)

- this smells like unintentional decent C2 infrastructure - unless it is absolutely intentional, in which case very nice cosplaying (I mean owner of domain controls and defines everything)

Isn't every single piece of content here a potential RCE/injection/exfiltration vector for all participating/observing agents?

100%, I wonder when we get LLM botnets (optional: orchestrated by an agent), if not already.

The way I see prompt injection is, currently there is no architecture for a fundamental separation of control vs data channels (others also think along similar lines of course, not an original idea at all). There are (sometimes) attempts at workarounds (sometimes). This apart from other insane security holes.

edit p.s. Simon has been talking about this for multiple years now, I should mention this in fairness (incl. in linked post)

This is a funny chain.. of exchanges, cheers to you both :)

At the risk of ruining 'sowbug having their fun, I'm not sure how Julian Jaynes theory of origins of consciousness aligns against your assumption / reduction that the point (implied by the wiki article link) was supposed to be "I am only my brain." I think they were being polemical, the linked theory is pretty fascinating actually (regardless of whether it's true; and it is very much speculative), and suggests a slow becoming-conscious process which necessitates a society with language.

Unless you knew that and you're saying that's still a reductionist take?.. because otherwise the funny moment (I'd dare guessing shared by 'sowbug) is that your assumption of fixed chain of specific point-counter-point-... looks very Markovian in nature :)

(I'm saying this in jest, I hope that's coming through...)

I've been thinking about this, take a look at this:

From Tool Calling to Symbolic Thinking: LLMs in a Persistent Lisp Metaprogramming Loop

https://arxiv.org/abs/2506.10021

edit but also see cons[3] - maybe viable for very constrained domains, with strict namespace management and handling drop into debugger. Also, after thinking more, it likely only sounds nice (python vs lisp training corpus and library ecosystems; and there's mcp-py3repl (no reflection but otherwise more viable), PAL, etc.) Still - curious.

In theory (I've seen people discuss similar things before though), homoiconicity and persistent REPL could provide benefits - code introspection (and code is a traversable AST), wider persistent context but in a tree structure where it can choose breadth vs depth of context loading, progressive tool building, DSL building for given domain, and (I know this is a bit hype vibe) overall building up toolkit for augmented self-expanding symbolic reasoning tools for given domain / problem / etc. (starting with "build up toolkit for answering basic math questions including long sequences of small digits where you would normally trip up due to your token prediction based LLM mechanism"[2]). Worth running some quick experiments maybe, hm :)

P.S. and thinking of agentic loops (a very uh contemporary topic these days), exposing ways to manage and construct agent trees and loops itself is (while very possibly recipe for disaster; either way would need namespaces not to clash) certainly captivating to me (again given effective code/data traversal and modification options; ideally with memoization / caching / etc.)

[1] https://arxiv.org/abs/2506.10021

[2] https://www.youtube.com/watch?v=AWqvBdqCAAE on need for hybrid systems

[3] cons (heh): hallucination in the metaprogramming layer and LLMs being fundamentally statistical models and not well trained for Lisp-like langs, and inevitable state pollution (unless some kind of clever additional harness applied) likely removes much of the hype...

Yes. I have (as part of Claude output) a

- `FEATURE_IMPL_PLAN.md` (master plan; or `NEXT_FEATURES_LIST.md` or somesuch)

- `FEATURE_IMPL_PROMPT_TEMPLATE.md` (where I replace placeholders with next feature to be implemented; prompt includes various points about being thorough, making sure to validate and loop until full test pipeline works, to git version tag upon user confirmation, etc.)

- `feature-impl-plans/` directory where Claude is to keep per-feature detailed docs (with current status) up to date - this is esp. useful for complex features which may require multiple sessions for example

- also instruct it to keep main impl plan doc up to date, but that one is limited in size/depth/scope on purpose, not to overwhelm it

- CLAUDE.md has summary of important code references (paths / modules / classes etc.) for lookup, but is also restricted in size. But it includes full (up-to-date) inventory of all doc files, for itself

- If I end up expanding CLAUDE.md for some reason or temporarily (before I offload some content to separate docs), I will say as part of prompt template to "make sure to read in the whole @CLAUDE.md without skipping any content"

Agree re: no need for heap allocation - for others: I recommend reading thru whole masscan source (https://github.com/robertdavidgraham/masscan), it's a pleasure btw - iirc rather few/sparse malloc()s which are part of regular I/O processing flow (there will be malloc()s which depending on config etc. set up additional data structs but as part of setup).

Quartz Composer

Have you looked at https://vvvv.org/ ? Maybe it's still comparatively too heavy but imho it's not that heavy (cf. touch designer and the likes). I want to play with it some more myself...

but then the shell commands were actually running llama.cpp, a mistake probably no human would make.

But in the docs I see things like

    cp llama.cpp/build/bin/llama-* llama.cpp

There is partial mitigation for RAPTOR: Counter-RAPTOR from 2017 (https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=795...)

Oh I had missed that, thank you btw! Need more of those BGP monitoring systems...

(and they performed an actual live BGP attack (not just simulation), neat)

Thank you for the pointer to LEANN! I've been experimenting with RAGs and missed this one.

I am particularly excited about using RAG as the knowledge layer for LLM agents/pipelines/execution engines to make it feasible for LLMs to work with large codebases. It seems like the current solution is already worth a try. It really makes it easier that your RAG solution already has Claude Code integration![1]

Has anyone tried the above challenge (RAG + some LLM for working with large codebases)? I'm very curious how it goes (thinking it may require some careful system-prompting to push agent to make heavy use of RAG index/graph/KB, but that is fine).

I think I'll give it a try later (using cloud frontier model for LLM though, for now...)

[1] https://github.com/yichuan-w/LEANN/blob/main/packages/leann-...

Understood, thanks! I wasn't even sure where to look - thank you

Out of curiosity, what conflict resolution options exist in mysql and/or mysql cluster (never checked / exp. in PG)? Because you'll always have to address conflicts of course - we come to CAP / PACELC. Hm [1][2] - looks like they support more strategies (possibly) but I mean none of them are somehow magical, and timestamp comparison based methods comprise the better part of offered strategy set (looks like?) - and "latest timestamp wins" at least used to be the default (did not read thoroughly mind you, was just curious)?

But I could be totally wrong - (1) curious if someone could link to things / explain, and (2) fyi ('stephenr) last write wins based on timestamp is a thing im mysql world as well (though again maybe set of options / different conflict resolution methods available is larger in mysql?)

[1] https://dev.mysql.com/doc/refman/8.4/en/mysql-cluster-replic...

[2] https://dev.mysql.com/blog-archive/enhanced-conflict-resolut... (nice writeup, maybe outdated idk?)

Do you mean the data sources it lists in those two articles are not valid? (I am referring to raw figures and not to actual textual content even). The charts themselves (and the proportions thereof) have been observed everywhere incl. in the mainstream media?

Can you present one counterexample as regards quantities / proportions of figures please? One source. (More of course if you'd like)

(My implicit point is that the proportions are so one-sided (orders of magnitude in difference; yes plural) that you will not find one; but please do find one (with actual quantities) and we can all check veracity of your source)

P.S. edit here is one of the sources the first wiki article lists (of multiple):

Lappin, Yaakov (2009). "IDF releases Cast Lead casualty numbers". The Jerusalem Post. Archived from the original on 26 March 2013. Retrieved 5 January 2024. =>

- https://www.jpost.com/israel/idf-releases-cast-lead-casualty...

- https://web.archive.org/web/20130326192603/http://www.jpost....

Where do we place Israel on that scale

That is, I think, an excellent and pertinent question.

For starters may I suggest applying straightforward quantification on a linear scale and observing the results? See the following two wiki articles / subsections:

1. https://en.wikipedia.org/wiki/Israeli%E2%80%93Palestinian_co... (see chart preceding the Gaza war (follow anchor))

2. https://en.wikipedia.org/wiki/Casualties_of_the_Gaza_war (Gaza war; see top table (and subsequent charts for more detailed breakdown if interested))

Based on this quantitative data where would you place Israel on that aforementioned scale?

I've read part of Nick Lane's other book, The Vital Question, cannot comment on this new one; TL;DR competent biochemist (from complete amateur standpoint at any rate), excellent science communicator; you can watch some of his talks online. e.g. the one linked on this new book's page is good: https://www.youtube.com/watch?v=vBiIDwBOqQA

He's really fascinated by the overall transformation process of inorganic matter -> organic matter, a sort of scientific fixation - which is always enjoyable when it's done by a competent scientist - and it's really captivating stuff. (The fact I haven't finished his previous book has nothing to do with the book material itself, if anything it really captivated me; it's just my not-amazing new habit of not finishing books...)

I agree! I'm sort of exploring "programmable filesystem" concept (using FuseFS) (for some notes, see [1]).

Re: ordered files: depends on FS. e.g. filesystems which use B+ trees will tend to have files (in directories) in lexical order. So in some cases you may not need a new FS:

    echo 'for f in *.txt; do cat "$f"; done' > doc.sh; chmod +x doc.sh

That said... wouldn't it be nice to have ridiculous easily pluggable features like

    echo "finish this poem: roses are red," > /auto-llm/poem.txt; cat ..

[1]: chaotic notes: https://kfs.mkj.lt/#welcome (see bullet point list below)

iirc there were some experiments where they rewired optic nerve and inner ear in mice to route (so to speak) to different areas of the brain (different cortical (i think?) destinations), and iirc the higher level biological structures of those areas were built up accordingly (regular visual cortex like neural structures for visual data, etc.) iirc was done on very young baby mice or somesuch (classic creepy stuff, do not remember which decade; Connectionism researchers).

does not answer the general good abstract question and "how semantics possible thru relative context / relations to other terms only?", but speaks to how different modalities of information (e.g. visual data vs. sound data) are likewise represented, modelled, processed, etc. using different neural structures which presumably encode different aspects of information (e.g. layman obvious guess - temporality / relation-across-time-axis much more important for sound data).

Ok, not a real zip bomb, for that we would need a kernel module.

Or a userland fusefs program, nice funky idea actually (with configurable dynamic filenames, e.g. `mnt/10GiB_zeropattern.zip`...

Yes and (for posterity / those lazy to read the linked Mastodon thread), if you read through the linked thread, you see that is nonsense and Yandex is very much a Russian business continually adjusting results based on Russian government input (to cross-check, see Wikipedia on Yandex).

Well, re: GDPR, for one Vlad is abjectly clearly wrong on email addresses not being PII. They are.

The mere fact of him relying on his rationalisation (of burner email addresses) over established GDPR definitions of PII is troubling. To me it rings immature and unprofessional. As a software engineer I shall treat PII with care and account for it. If a CEO is this defensive about their clearly wrong opinion, it's a red flag to me.

This could not have come at a better time for me, thank you!

I've been tinkering with an idea for an audiovisual sandbox[1] (like vvvv[2] but much simpler of course, barebones).

Idea is to have a way to insert LM (or some simple locally run neural net) "nodes" which are given specific tasks and whose output is expected to be very constrained. Hence your example:

    "question -> answer: float"

[1]: loose set of bulletpoints brainstorming the idea if curious, not organised: https://kfs.mkj.lt/#audiovisllm (click to expand description)

[2] https://vvvv.org/

This is great, thank you so much for sharing!

I have found that a general pattern of setting up a memory arena or anything of that kind does help, especially of course if one anticipates more frequent / heavier usage of heap. Helps with performance (e.g.: faster allocations), memory fragmentation (which itself also helps with performance indirectly of course) and other things. Can be very simple.[1]

Or more complicated (if anticipating a lot of allocation work for very varying buffer sizes) - e.g. slab allocators. memcached is an example where this is used, a couple pictures explain the gist.[2]

[1]: note: can be even simpler of course, but quick example of structs used:

```

  typedef struct
      char *memory;
      size_t size;
      size_t used;
  } memory_arena_t;

  typedef struct {
      memory_arena_t *arenas;
      size_t arena_count;
      size_t max_arenas;
      size_t arena_size;
      size_t total_size;
      size_t total_used;
  } memory_allocator_t;

[2] https://siemens.blog/posts/memcached-memory-model/ - I'm sure that when heap is visualised, it would show how this helps keeping fragmentation at bay as well (this helps wasting fewer memory pages, too).

This is useful feedback for me. Thanks (no further comments, but I think I know the reason why it's been this way especially as of late)

Re: LLMs & diagrams - in general, diagrams and tables as info compression tool (both in the general sense as well as in the practical concrete "optimise for token / context window" sense) - e.g. today as part of request to do 'deep research' on Dwarf Fortress personality / psychology system, at a late point (preparing to relaunch with a fresh empty context window among other things) I asked GPT 4.5 to (among other diagrams) draw me a concise 'psychological data flow diagram' (I was kind of vague and was deliberately pushing for abstraction / compression) -

among (many elaborate) other things it gave me - and I liked it (NB don't trust it willy nilly w.r.t. the below of course) - (auto-indented by 2 spaces hope formatting works) =>

```

  DWARVEN PSYCHE DATA FLOW
  ───────────────────────────────────────────────────────────────────
  
        External Events
    (Trauma, Success, Social)
              │
              ▼
  ┌─────────────────────────┐
  │     Event Processing    │─── Modulated by → Personality facets
  │ (Emotion generation)    │─── Modulated by → Personal values
  └───────────┬─────────────┘
              │ Generates
              ▼
  ┌─────────────────────────┐
  │  Emotional Reactions    │─── Short-term emotion (Anger, Joy, Sadness)
  │  (Immediate Thoughts)   │
  └───────────┬─────────────┘
              │ Stored as
              ▼
  ┌─────────────────────────┐
  │    Memory Storage       │─── Short-term → Long-term memories (core)
  │ (Core & transient)      │─── Decay/Replacement over time
  └───────────┬─────────────┘
              │ Recalled as
              ▼
  ┌─────────────────────────┐
  │ Memory Re-experiencing  │─── Repeated emotional impacts
  │ (Periodic Thoughts)     │
  └───────────┬─────────────┘
              │ Accumulate
              ▼
  ┌─────────────────────────┐
  │      Stress Level       │─── Increased by negative memories
  │  (Running total score)  │─── Decreased by positive memories
  └───────────┬─────────────┘
              │ Monitored
              ▼
  ┌─────────────────────────┐
  │  Stress Threshold Check │─── If threshold breached → Psychological Crisis
  │                         │─── Else → Coping behaviors activated
  └───────────┬─────────────┘
              │
              │
        ┌─────┴─────┐
        │           │
        ▼           ▼
  ┌───────────┐ ┌─────────────────┐
  │ Coping    │ │ Psychological   │
  │Mechanisms │ │ Breakdown       │
  │(Needs met,│ │ (Tantrum,       │
  │ hardening,│ │  Depression,    │
  │ social)   │ │  Insanity)      │
  └───────────┘ └─────────────────┘
        │                │
        │                ▼
        │       ┌───────────────────┐
        │       │ Personality Change│
        └──────▶│ (Facet alterations│
                │ via trauma, events│
                └───────────────────┘

p.s. it chose the syntax/format itself; regardless, some time ago when asked for guidance re: how to manage sliding context window, it did suggest tables itself (user employing them for concise input - and likewise requesting tabulated/diagrammatic/schematic output).

p.p.s. (edit) many good very particular insights, if anyone's by chance interested then lmk, I'll ping once distilled interesting output is on a not-yet-extant blog (it's gonna happen finally)...

Agree regarding easiness of building rust (`cargo build`), extremely satisfying (git clone and cargo build...)

Does anyone have any comments on Bazel[1] because I'm kind of settling on using it whenever it's appropriate (c/c++)?..

[1] https://bazel.build/

Since I was just looking at this accidentally, here are some examples of how to query at a ~cent-per-query cost level (just examples but quite illustrative): https://commoncrawl.org/blog/index-to-warc-files-and-urls-in...

I understand what you mean re: Arch wiki (I'm a fan of it even though not an arch user) but I genuinely suggest you go over and read some of the FreeBSD Handbook. Just look through the ToC (itself a nice thing) and pick something.

It is a cohesive whole which can be read from start to finish (it is an actual book). This is also how the whole system feels as well (as others have commented). Things are integrated and coherent. Example: freebsd has its own libc[0], and the kernel and libc do feel (from old experience) like a consistent unit, so to speak.

So IMO in terms of system cohesiveness (and its documentation which is a marvel unto itself but also represents the thing it covers), it's on a whole other level.

[not even using FreeBSD for any servers right now[1], but I have deep respect and admiration for the project and its team]

https://docs.freebsd.org/en/books/handbook/

[0] that's the thing, as others have commented, Linux is really two parts (GNU+Linux) whereas e.g. FreeBSD is for most intents and purposes "one" internally cohesive part.

[1] though about to get a large old refurbished Dell server with 2xXeon for personal tinkering (you can find them cheap; beware of power usage tho...) and will likely set up FreeBSD as host, with ZFS, etc...

case in point - dealing with race conditions.

100%. Case in point for case in point - I was just scratching my head over some Claude-produced lines for me, thinking if I should ask what this kind entity had in mind when using specific compiler builtins (vs. <stdatomic.h>), like, "is there logic to your madness..." :D

  size_t unique_ips = __atomic_load_n(&((ip_database_t*)arg)->unique_ip_count, __ATOMIC_SEQ_CST);

but if you need to use Signal as opposed, then you are already assuming an adversary that does more than just snoop on the public Wifi he offers.

No, not necessarily. In fact I'd claim that we should all use Signal so that usage of Signal would not imply any kind of user profile (would not rconstitute any kind of meaningful signal where one could infer what kind of user they are).

I do believe that there's a spectrum of users with a corresponding spectrum of appropriate threat models.

If my own threat model (that I felt I had to adopt) was particularly gnarly, I would (1) use Signal sandboxed / in a VM, tunnelling all traffic through Tor (e.g. Tor listens on socket exposed to VM so that there's no easy way to work around tunnel), and/or (2) if particularly gnarly - would set up pre-shared one time pads with counterparties where possible, and use them to authenticate further, perhaps encrypt further (maybe just encrypting a session key, to save most of OTP) - essentially definitely not deem Signal enough by itself.

Signal correctly focuses on privacy, not on anonymity. The wider your set of claims as to what kinds of properties (from the set of: privacy, anonymity, censorship-circumvention, etc.) you provide, the higher the probability you're going to screw up with one of these, I'd say. Better to combine several tools where possible if your needs require it.