catwell

This has been my Twitter / X banner for at least 10 years :)

https://x.com/pchapuis/header_photo

You are most likely confusing OpenClaw with Moltbook, which is the project that had the most glaring vulnerabilities. But even if OpenClaw was full of holes it would not matter.

Peter is not just a random "vibe coder" and he does not need to be hired by OpenAI to achieve "success". Before this he founded and sold a company that raised €100M. It is not his first project in the space either (see VibeTunnel for instance).

OpenAI is not hiring him for his code quality. They are hiring him because he proved consistently that he had a vision in the space.

Antirez (the author of this interpreter) uses it for the Redis test suite.

Personally, I know Lua and Python very well but I still used TCL a few years ago for something very specific: using ODBC on Windows. I gave more details on the Lua mailing list here: http://lua-users.org/lists/lua-l/2021-01/msg00067.html

You probably know but others might not: they have the same author.

Not only that, he's very enthusiastic about AI analyzers such as ZeroPath and AISLE.

He's written about it here: https://daniel.haxx.se/blog/2025/10/10/a-new-breed-of-analyz... and talked about it in his keynote at FOSDEM - which I attended - last Sunday (https://fosdem.org/2026/schedule/event/B7YKQ7-oss-in-spite-o...).

Most people don't use the standard library to make a HTTP request in Python either...

I agree with the sentiment though, I even gave a talk about this at Lua Workshop 2013 (https://www.lua.org/wshop13/Chapuis.pdf) around that issue. There are good reasons why several important but OS-specific features are not included in the core language. Discussion around a "blessed" extended standard library module arise from time to time but never lead anywhere.

The Lua community - at least the one around PUC Lua - is reasonably small and you can typically look at what active popular projects use to figure out the best libraries. The LuaRocks download count can be an indicator as well. But I agree this is still a problem.

Their Granite family of models is actually pretty good! They just aren't working on the mainstream large LLMs that capture all the attention.

If you're looking for something light, self-hostable and a bit more "social" (i.e. with pull requests and bug creation from the web) I recommend looking at https://tangled.org It doesn't render perfectly in Dillo but basic features appear to work.

However I really like what you've done here for Dillo as well.

It's way more complicated than this.

First, this is mostly about things that happened before his election.

The tribunal ruled he did not personally benefit, and he did not directly solicit money to finance his campaign either.

However, some of his closest allies (who would become his ministers later) did the latter. The tribunal could not find any direct proof he was involved but ruled there were enough "converging indications" that he knew and did nothing to stop it.

No, he means most NVIDIA-related software assumes a x86 CPU whereas this one is ARM.

You can use a remote FS but it is nowhere close to the experience VSCode gives you. For instance, running code will run it locally, not on the remote machine.

Hey! I'm a Sublime Text user since ST2 in 2011.

I love ST (my last blog post is https://blog.separateconcerns.com/2025-01-04-teal-lsp-sublim...) and I think the main thing lacking compared to the competition is the remote development experience.

I work in AI so we typically work over SSH on machines with big GPUs. Most of my colleagues use VSCode because it has a very good Remote Development extension.

Yes, if you assume some of the clients go away indefinitely without giving their share back and you don't have a solution to deal with this, it's a problem.

Solutions are relatively easy on a client-server model (but do you really need something like ITC with a server...?) For instance the server could delegate its part of the interval with a timeout and claim it back once it expires.

If you know you have this model you can find a different way to split the interval to avoid the issue of the linear number of bits. Nodes can split their interval however they want.

Also I had forgotten but here is a more recent follow-up to Fred Hebert's post: https://ferd.ca/a-bridge-over-a-river-never-crossed.html

I don't really know what you mean regarding pathological subdivisions, but the case where nodes go offline without merging first is a real issue. There are ways to work around it but if you have to do so you lose a lot of its advantage compared to other schemes.

When I did that talk I was at the point you are now, trying to find a real use case. I had considered them for Lima but we were actually find with version vectors.

I think the case where ITCs can really shine is when you have a lot of short-lived nodes. That could be containers or serverless functions, for instance. I didn't think about the tracing use case but it makes a lot of sense, you can fork a new node per request.

Yes, the original link is dead, and that one doesn't work for me currently. I'll edit the post if I find a working one.

EDIT: I found where the paper has moved, I have updated the article.

Hello, author here. Sorry about the lack of clarity, this article is the transcript of a 5 min lightning talk and it was really hard fitting all the relevant content in that little time :) (In retrospect that was a poorly chosen topic. When I picked it I thought the talk would be 10 min, 5 min is too short to explain a subject like this.)

How that curve is initially drawn isn't clear at all. Is it flat and becomes complex over time by forking (+ data modification)?

Yes, the initial curve is typically constant 0.

Why are interval boundaries real-value in a system that cannot actually express real numbers?

Like snthpy said "real" is a shortcut to say infinitely subdivisible. The numbers themselves are actually rationals.

How are the intervals / portions decided? Is that simpler than generating UUIDs?

Nodes are forked from an existing node, that node decides which portion of its interval it gives to the new node. You pick the splitting point to keep complexity low.

Regarding comparison: you always know the values of the whole curve. When I say "a node only has to know about its share of the interval" I only mean the ID space. In a version vector there is a direct link between identifiers and counters, whereas here outside of your share of the interval you don't know who owns what or how many devices there are at any given point.

Lima did not use ITC in its product anyway, we used classic version vectors. We considered them for future evolutions but never implemented it. It's funny that Fred Herbert's use case was a "peer-to-peer Dropbox", because it is basically what Lima was.

I don't know many systems that use ITC. Version vectors are simpler and sufficient in most cases. One of the authors of the original paper mentioned in a later presentation (https://cbaquero.github.io/web/pdf/SDLtime2021.pdf) that they were used for tracing, in particular in a 2015 system called Pivot Tracing.

There are several alternatives using Lua too, including for instance PICO-8 https://www.lexaloffle.com/pico-8.php

He wrote a science-fiction book, then did some things with e-ink hardware and some with AI.

The best way to pull this off is to bet the tool will end up shutting down and build the replacement before it does. A good example of this is Pinboard: Maciej knew the product inside out, and he knew what being acquired by Yahoo meant. So he started building Pinboard in 2009, caught the various exodus waves from Delicious in the later years (esp. 2011) and ended up acquiring it for $35k in 2017.

It works properly with PyTorch. For what it's worth at $DAYJOB we switched from Poetry to Rye starting from version 0.15 (even before it supported uv) for that reason initially.

Teal (https://github.com/teal-language/tl) is the closest we have from a "TypeScript for Lua". It is natively supported by many projects now, including game engines such as the Bevy scripting plugin and Defold.

Talking about bait and switch for Redis makes no sense.

Redis is a 15 years old project started in 2009 by Salvatore 'Antirez' Sanfilippo. He worked on his startup, then at VMWare, them at Pivotal, and only joined Redis Labs (created in 2011) in 2015.

In 2018 Redis Labs changed the license of their modules and Antirez published http://antirez.com/news/120 In 2020 he quit.

Anyway I agree with the conclusion: Redis will be forked, the fork will win and Redis Labs will become irrelevant.

I saw a presentation about this last week at the Generative AI Paris meetup, by the team building the next generation of https://vidal.fr/, the reference for medical data in French-speaking countries. It used to be a paper dictionary and exists since 1914.

They focus on the more specific problem of preventing drug misuse (checking interactions w/ other drugs and diseases, pathologies, etc). They use GPT-4 + RAG with qdrant and return the exact source of the information highlighted in the data. They are expanding their test set - they use real questions asked by GPs - but currently they have 0 % error rate (and less than 20 % cases where the model cannot answer).

It depends a lot on the rooms you go too as well, it's a reflection of the various communities (in Europe mostly, although quite a few people come from overseas too).

Not really. AFAIK there are platform doors on lines 1, 4, 14 and 13.

Lines 1, 4 and 14 have rubber tyres and platform doors because they are fully automated (or in the case of line 4 in the process of being fully automated). So far Paris only fully automates rubber tyres lines.

Line 13 has classic metal tyres and is only semi-automated, but it has platform doors because it is very high traffic. Most Parisians avoid line 13 at rush hours because it is probably the most packed line in the city.

It's a different sampler too.

https://separateconcerns.com/

Posting occasionally since 2009.

WebGPU does not play in the same league as tfjs, it is a successor to WebGL, the technology tfjs is implemented with. There is already a WebGPU backend for tfjs: https://www.npmjs.com/package/@tensorflow/tfjs-backend-webgp...

There are also several ONNX runtimes using WebGPU in case you want to run models written with PyTorch.