williamstein

Title says "open source", but the Business Source License (BSL) is not an Open Source Initiative (OSI) approved open-source license.

Their new CLI agent tool [1] is written in Python unlike similar agents from Anthropic/Google (Typescript/Bun) and OpenAI (Rust). It also appears to have first class ACP support, where ACP is the new protocol from Zed [2].

[1] https://github.com/mistralai/mistral-vibe

[2] https://zed.dev/acp

For example, https://github.com/williamstein/nats-bugs/issues/5 links to a discussion I have with them about data loss, where they fundamentally don't understand that their incorrect defaults lead to data loss on the application side. It's weird.

I got very deep into using NATS last year, and then realized the choices it makes for persistence are really surprising. Another horrible example if that server startup time is O(number of streams), with a big constant; this is extremely painful to hit in production.

I ended up implementing from scratch something with the same functionality (for me as NATS server + Jetstream), but based on socket.io and sqlite. It works vastly better for my use cases, since socketio and sqlite are so mature.

Instead you can use https://github.com/coder/code-server, which is really vscode running in your browser. You then get all extensions, etc.

codex-cli is a neat example of an open source Rust program that uses Landlock to run commands that an LLM comes up with when writing code (see [1]). The model is that a user trusts the agent program (codex-cli), but has much more limited trust of the commands the remote LLM asks codex-cli to run.

[1] https://developers.openai.com/codex/security/

- 200 day’s maintenance free operation

- water jets to clean vacuum itself

- claims that it is much more quiet

If I hired a software developer a few years ago, I might expect them to do roughly what Claude Code does today on some task (?). If I hired a dev today I would expect much more from them than what Claude Code can currently do.

> Some models (looking at you, GPT-5-Codex) seemed to mistake “more complex” for “better.”

That's what working with GPT-5-Codex on actual code also feels like.

bun has 10x the issues matching "segfault" as deno

- deno 44: https://github.com/denoland/deno/issues?q=is%3Aissue%20state...

- bun 464: https://github.com/oven-sh/bun/issues?q=is%3Aissue%20state%3...

There is a nice table here

https://github.com/rustfs/rustfs?tab=readme-ov-file#rustfs-v...

comparing RustFS to MinIO, including a claim about the MinIo support price.

Some small additional details: 23 years not 30. Also, I think Julia was started as much in response to Octave/Matlab’s shortcomings. I don’t know if it is written down, but I was told a big impetus was that Edelman had just sold his star-p company to Microsoft, and star-p was based around octave/matlab.

- https://julialang.org/blog/2012/02/why-we-created-julia/

AI is very fast at generating working self contained complicated code, which makes it too easy to establish a difficult to finish architecture.

1.02**17 = 1.400..., whereas 1.02**35 = 1.99...

At 2% inflation prices increase by 40% every 17 years, and it takes 35 years for them to double. At 3% (closer to real inflation), prices would double every 23 years: 1.03**23 = 1.97...

I am also very curious what people think about this. To me, as a project, Node gives off a vibe of being mature, democratic and community driven, especially after successfully navigating then io.js fork drama etc a few years ago. Clearly neither bun nor deno are community driven democratic projects, since they are both VC funded.

They have a bunch of claims comparing this to JuiceFS at https://www.zerofs.net/zerofs-vs-juicefs

I am in no way affiliated with JuiceFS, but I have done a lot of benchmarking and testing of it, and the numbers claimed here for JuiceFS are suspicious (basically 5 ops/second with everything mostly broken).

Incidentally, the application I'm reworking to use btrfs is cocalc.com. One of our main use cases is distributed assignments to students in classes, as part of the course management functionality. Imagine a class with 1500 students all getting an exact copy of a 50 MB folder, which they'll edit a little bit, and then it will be collected. The copy-on-write functionality of btrfs is fantastic for this use case (both in speed and disk usage).

Also, the out-of-band deduplication for btrfs using https://github.com/Zygo/bees is very impressive and flexible, in a way that ZFS just doesn't match.

It can be useful to create a file server with one filesystem/subvolume per user, because each user has their own isolated snapshots, backups via send/recv are user-specific, quotas are easier, etc. If you only have a few hundred users, ZFS is fine. But what if you have 100,000 users? Then just doing "zpool import" would take hours, whereas mounting a btrfs filesystem with 100,000 subvolumes takes a seconds. This complexity difference was a show stopper for me to architect a certain solution on top of ZFS, despite me personally loving ZFS and having used it for a long time. The btrfs commands and UX are really awkward (for me) compared to ZFS, but btrfs is extremely efficient at some things where ZFS just falls down.

The main criticism in this thread about btrfs involves multidisk setups, which aren't relevant for me, since I'm working on cloud systems and disk storage is abstracted away as a single block device.

So do I and BTRFS is extremely good these days. It's also much faster than ZFS at mounting a disk with a large number of filesystems (=subvolumes), which is critical for building certain types of fileservers at scale. In contrast, ZFS scales horribly as the number of filesystems increases, where btrfs seems to be O(1). btrfs's quota functionality is also much better than it used to be (and very flexible), after all the work Meta put into it. Finally, having the option of easy writable snapshots is nice. BTRFS is fantastic!

I strongly agree. LLM’s have eviscerated the core idea and motivation behind using the GPL, in a way I didn’t at all see coming. We’ve published a lot of very unique GPL code (eg in sagemath), which anybody can now easily “regenerate” as part of some other closed (or open) software using an LLM. They wouldn’t even know they are creating a derived work of our GPL code. I have had to come to terms with this...

Kevin Buzzard told me that the worry that it might in fact be wrong is a huge motivator for him. I also once asked Serge Lang why so much mathematics is correct (which surprised me coming from programming where everything has bugs), and he said; “people do a large number of consistency checks beyond what is in the published proofs, which makes the chances the claimed results are correct much, much higher.” Another related quote Bryan Birch told me once: “it is always a good idea to prove true theorems.”

Site Description: Very efficient backup system based on the git packfile format, providing fast incremental saves and global deduplication (among and within files, including virtual machine images).

In the context of react codebases, people typically use either functional components everywhere or class components. Mixing the two approaches is frustrating and painful, eg you can’t use any of the hooks in your codebase in a class component. Perhaps the OP was talking about this, but just being really vague.

Not open source: “You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.”

This is probably the closest thing to that: https://www.assemblyscript.org/

WASM adds the ability to run a local copy of SQLite (or even PostgreSQL) entirely in the browser.

Fascinating observation. Maybe he is better at research partly by being disciplined to not have such opinions. Having an opinion can bias one’s approach to a problem, making it harder to solve.

Same, and I literally started Cython. :-)

Also, Redis is being opened sourced via the AGPL, whereas Valkey is BSD licensed (like Redis used to be). They are both officially open source licenses, but BSD is much, much more permissive.