Hacker News: wlib

Towards a More Useful Model of Distributed System State

wlib — Sat, 01 Nov 2025 13:10:44 +0000

Article URL: https://gist.github.com/wlib/1a8ed2af0a5a00241697182e4a83b101

Comments URL: https://news.ycombinator.com/item?id=45781379

Points: 2

# Comments: 0

New comment by wlib in "LiveStore: State management based on reactive SQLite and built-in sync engine"

wlib — Tue, 27 May 2025 21:13:17 +0000

That’s very elegant, thanks!

New comment by wlib in "LiveStore: State management based on reactive SQLite and built-in sync engine"

wlib — Tue, 27 May 2025 16:43:48 +0000

I’ve been working on a very similar sync problem and hit this too. I think the way forward is to use a broadcast channel to elect an individual worker that communicates with all other contexts using the broadcast channel.

New comment by wlib in "Tencent's 'Hunyuan-T1'–The First Mamba-Powered Ultra-Large Model"

wlib — Sun, 23 Mar 2025 17:08:18 +0000

The filler tokens actually do make them think more. Even just allowing the models to output "." until they are confident enough to output something increases their performance. Of course, training the model to do this (use pause tokens) on purpose works too: https://arxiv.org/pdf/2310.02226

New comment by wlib in "Chrome 133 Supports DOM State-Preserving Move with moveBefore()"

wlib — Wed, 05 Feb 2025 20:17:21 +0000

You can still have a framework-specific render tree that maps to the DOM that tracks changes with signals instead of diffing. We’re just saying that there’s no requirement for diffing algorithms anymore to performantly and correctly reconcile state to the DOM. Keyed children was the last place it was needed.

New comment by wlib in "Chrome 133 Supports DOM State-Preserving Move with moveBefore()"

wlib — Wed, 05 Feb 2025 18:03:58 +0000

The biggest benefit to this is that it makes one of the slowest parts of virtual DOM diffing (longest common subsequence) no longer required. After this becomes supported in the mainstream, not even signal-based frameworks will have to include VDOM algorithms. I know this because I remember pushing for this to be supported a few years ago — a nice reminder that the standards are evolving and that nothing stops you from being a small part of the effort.

Next up — DOM parts and standardized signals, unified.

New comment by wlib in "Maintaining and sustaining soil health"

wlib — Wed, 15 Jan 2025 16:03:39 +0000

With ~2/3 (and growing) of Earth’s land area being arid, you’d expect there to be a lot more interest in reverse-desertification. It’s pretty well established by now that it’s almost entirely a labor allocation issue given that there’s success stories all over the world [1] (including in the US [2]) to just create earthworks that slow and divert water. Water seems to be the biggest single issue and so many deserts actually get enough of it during flash floods. With how much Elon is interested in terraforming Mars why not just start here?

[1] https://youtu.be/UAmai36XJDk?list=PLoU8oWWwU-06BGLH5y7AMbybv... [2] https://youtu.be/3JyEHdJS94s?list=PLoU8oWWwU-06BGLH5y7AMbybv...

New comment by wlib in "Observable API Proposal"

wlib — Fri, 28 Jul 2023 23:53:59 +0000

The key is topological sorting of a dependency graph. This can be done implicitly by storing a reactive variable node’s depth once it is created, and just making sure that updates are enqueued in separate queues per depth.

I have a somewhat small implementation that transparently batches updates with queueMicrotask in this library (bruh): https://github.com/Technical-Source/bruh/blob/a829af9df9405b...

New comment by wlib in "SparseGPT: Language Models Can Be Accurately Pruned in One-Shot"

wlib — Wed, 03 May 2023 23:49:24 +0000

My memory says that there’s a “Chinchilla” paper showing how to make the best model with a given training budget. There’s a trade-off between the amount of training data and the size of the model itself. Chinchilla under-training would mean that the model is too big for the amount of training data used. Llama is Chinchilla over-trained in that there is a ton of data relative to the small size of the model.

Note that this is still desirable for inference because you want the most possible training on whatever model you can actually fit in your memory.

New comment by wlib in "There are 2¹⁰²⁴ things you can do with a kilobit"

wlib — Mon, 11 Jul 2022 00:56:28 +0000

Exactly - the twitter thread would be really improved if everyone read an introduction to information theory. There are 1024 bits of information in a kilobit, and that's enough information for 2^1024 unique messages. The interpreter of the messages judges what the message information means, but the Kolmogorov complexity of a message is inescapable - you would need to modify the interpreter to squeeze out more messages (which is nothing more than pre-transferring information to the receiver)

New comment by wlib in "Show HN: A tiny and fast reactive observables library via functions"

wlib — Sun, 26 Jun 2022 20:58:54 +0000

I made a library in which state management started the same way. A simple approach is great for performance-sensitive parts and it's easy to write, but there is very little helpful structure to it. Reactivity fails very easily, consider a dependency graph like this: a -> b a -> c b,c -> d In this case, updating `a` would cause d to be calculated (and reactions run) twice. Also, update batching is absolutely necessary for anything non-trivial.

At least for what I made, I don't think it's too complex for what it provides. It transparently integrates with the event loop and only runs what it needs to, at the cost of (min-brotli) 432 bytes at the moment. Compare the "naive" SimpleReactive with the complete FunctionalReactive version here: https://github.com/Technical-Source/bruh/blob/main/packages/...

New comment by wlib in "Let's stop ascribing meaning to code points (2017)"

wlib — Sun, 26 Jun 2022 20:34:23 +0000

I just wanted to use a concrete example of a featural writing system. It would of course not be Hangul if it had to accommodate all phonemes. The other direction to take would be to create a sophisticated (probably ML) model that could enable certain features to be optimized, like speed of syllable recognition. If we are constructing a modern writing system then that would definitely be a good approach.

New comment by wlib in "Let's stop ascribing meaning to code points (2017)"

wlib — Sun, 26 Jun 2022 19:59:13 +0000

What about a Hangul inspired version of IPA? https://en.wikipedia.org/wiki/Hangul

New comment by wlib in "When or If"

wlib — Mon, 14 Mar 2022 17:30:22 +0000

I initially thought that “if” should be the obvious choice, ignoring sass entirely. However, it’s clear that “when” makes more sense than “if” given CSS’s interpretation anyways. “if” sort of implies a more “one-time” use like in a template/macro or preprocesser. “when” really captures the temporal invariance of CSS’s conditionals.

New comment by wlib in "The λ-Cube"

wlib — Sat, 15 Jan 2022 20:34:55 +0000

I’m on my phone so I can’t really give this the response that it’s owed, but most of what I want to say is that I don’t think we disagree as much as you think. My mention of languages being the wrong approach to general programming is a key aspect of my position. You’re right that DSL’s are usually not a great idea, but that seems like more of an issue with the “syntax-chasing”. The affordances that a syntax forces upon everyone are why it takes a decade to add generics to Go and why macros are even used to begin with. As we see from the various notations used for equivalent math, we probably we be better off encoding the structure as a flexible semantics graph and then “projecting the syntax” however the programmer wants. Keep in mind that what I write is about possibilities more than what you would be forced to do every project. You wouldn’t expect everyone to import random type systems more than you would expect everyone of write and import their own random crypto system libraries. Some of the most popular languages out there have absolutely zero static checks. Would it be so bad to write a Turing complete static check function? Why do we care so much about decidability that we can’t even consider it in useful exceptions? Also, do you think macros a la lisp would be so bad if they had more powerful type systems backing them up and more flexible editors to understand them?

New comment by wlib in "The λ-Cube"

wlib — Sat, 15 Jan 2022 20:12:47 +0000

I’m aware of math being entirely useful outside of programming - my little rant is more about how little programming is inspired by math

New comment by wlib in "The λ-Cube"

wlib — Sat, 15 Jan 2022 20:09:04 +0000

Very nice; you get to the practical lesson of it in a fairly straightforward manner while keeping interesting tangents where they aren’t distracting.

New comment by wlib in "The λ-Cube"

wlib — Sat, 15 Jan 2022 20:01:37 +0000

Somewhat unrelated to this link, but I really think that it’s interesting how much effort we put into the theory side of languages/types - with almost no one in industry applying these lessons. The essence of this is just something along the lines of “What if we unified values with types, so we could have more useful type checking?” We have billions of dollars being spent and thousands of smart people working for decades, who don’t even get to use a proper type system - forget about statically-checked polymorphism or dependent typing. It’s not even as if we lost the ball, we’re running in the wrong direction. It’s almost trivial to bolt on gradual typing to a language. It’s also not too hard to retrofit dependent types (just don’t bother with Turing-incompleteness). The whole point of these type systems is to better model systems, so why not go the extensible route of letting anyone hook into the “type checking” phase? Import affine types (that decades old thing that got rust popular); write your own domain-specific checker, even. It’s so frustrating to see how beautiful ideas just die because we feel comfortable the way things are now. Maybe language was the wrong abstraction to begin with. Sorry to derail, but this feels like the only path to truly popularize the lambda cube as a concept.

New comment by wlib in "Show HN: Minimator, a Minimalist Graphical Editor"

wlib — Mon, 10 Jan 2022 02:11:29 +0000

Just in case you or anyone doesn’t know, pinch to zoom on touchpads is exposed as just scrolling with the control key held down. You can listen for it with the wheel event and look at the ctrlKey and deltaY properties.

New comment by wlib in "You shouldn't parse the output of ls(1)"

wlib — Fri, 31 Dec 2021 16:14:49 +0000

Why do we impose hierarchy so much in file systems? We already allow hard and soft links, so it’s not even a tree anyways. Why not just allow any reference types you want; no name with extensions, but a set of tags. Why not identify files the same way a graph database query identifies nodes?