I love chaining because it reduce the number of occurrences of that problem.

I mean, I can do the "critical reading of CEO claim" part myself, thank you very much.

And it’s not just CEOs. Politicians, spokepersons of foreign nations, academics, journalists also do that "X said a thing" thing. It’s perfectly fine. I don’t need or desire the personal take of the journalist on that declaration. They have opinion pieces for that.

My observation:

- When you start from the "what do I want to back up" perspective, there are tons of excellent solutions. Using ZFS? Type "zfs backup" into your favorite search engine and you'll find something that fits; the same goes for MariaDB, Postgres, btrfs… - When you start from the "where do I want to back up to" perspective — S3, FTP, WebDAV? Same thing, you're spoiled for choice.

However, once you ask "I want to back up this to there", compatibility between the two can get thorny. Add requirements like "I want my backups encrypted," and you might not find a solution at all.

And even if you do? Congratulations, you now have as many backup tools as you have "what I want to back up" / "where I want to back up to" pairs, each with its own separate configuration in a separate format, with different encryption keys in a different format. And when your annual disaster recovery drill comes around… well, let's just say it makes you want to leave this planet.

So 5 years ago I created uback, a system that acts as an intermediary between "sources that produce backups" (a few are built-in, but the idea is you can write your own in shell or your favorite programming language) and "destinations that can receive those backups" (same), handling encryption, compression, and retention policy.

I never promoted it until now, but I'm taking the occasion of 0.7(.1) to do so: I consider this version "final," feature-complete. Going forward, it will very likely be bug fixes and routine maintenance only. Not in the "I'm abandoning the project" sense, but in the "it does everything I need, and I don't see anything to add" sense. The only area I'm not entirely happy with is the configuration system, but the problem is legitimately (and surprisingly!) complex, and I don't really see how to do significantly better.

Why not 1.0 if I consider 0.7 "final"? Because I'm reserving "1.0" for the (unlikely, but you never know) scenario where "the project gains traction, with many users and contributors, and after extensive feedback we publish a definitively stable 1.0" (in other words: when it's not just me who considers the current version final). In the meantime, what do I reserve the right to break in 0.x? Everything except the ability to restore old backups. Are there good chances I'll (intentionally) break things? The odds are low for the configuration system, virtually zero for everything else.

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

Points: 1

# Comments: 0

Here, a 186-bits partial collision, found in less than two minutes on my CPU, by brute force :

sha256(cbfad45814d54d1d56d30de387d957ed3b50e06270ad6e4b897f4a0000000000) = 692207e28eb8dd3eb4f8fab938ea5103faa1060c3bbed204f564e10c65d06b33 sha256(cbfad45814d54d1d56d30de387d957ed3b50e06270ad6e4be8c33e0000000000) = 006347a21f7c9b3eb4fa52b75d0e5a03dbe556b579d6d2867d44c38c06546f6f

(in Python :

>>> hashlib.sha256(bytes.fromhex("cbfad45814d54d1d56d30de387d957ed3b50e06270ad6e4b897f4a0000000000")).hexdigest()

'692207e28eb8dd3eb4f8fab938ea5103faa1060c3bbed204f564e10c65d06b33'

>>> hashlib.sha256(bytes.fromhex("cbfad45814d54d1d56d30de387d957ed3b50e06270ad6e4be8c33e0000000000")).hexdigest()

'006347a21f7c9b3eb4fa52b75d0e5a03dbe556b579d6d2867d44c38c06546f6f'

>>> a = hashlib.sha256(bytes.fromhex("cbfad45814d54d1d56d30de387d957ed3b50e06270ad6e4b897f4a0000000000")).digest()

>>> b = hashlib.sha256(bytes.fromhex("cbfad45814d54d1d56d30de387d957ed3b50e06270ad6e4be8c33e0000000000")).digest()

>>> sum((x^y^0xff).bit_count() for (x, y) in zip(a, b))

186

)

Intuition pump : the expected number of equal bits for two random inputs is 128.

Now that everyone and its dog does those "goofy" illustrations, I find them insufferable.

From the description, I believe it's random string hard-coded in the executable + user-provided password => AES key ?

Also… "full offline", but "my API is on a digital ocean droplet" ? What ?

(I guess the API to generate a .exe with its own random string ? But again, very unclear of what it is, what’s it’s doing, and how)

Now, give me ephemeral, per-connection procedures (call them unstored procedures for fun) that I can write in the language I want but that run on provider side, sure I’ll happily use them.

By comparison o3 is brutally honest (I regularly flatly get answers starting with "No, that’s wrong") and it’s awesome.

That’s a very strange priority. Why would non-technical users would be interested in a file format and a Python library ?

Very roughly speaking, putting the complication of "point at infinity" problem under the rug, a characteristic feature of a EC is that a straight line passing through two points on the curve will pass through a third point on the curve (yes, unless you take a vertical line, point at infinity). So you can define an "addition of points on the curve" : take two points A and B, draw a straight line passing through them, name the third intersection point between the line and the curve C, declare A + B = C (actually there’s a symmetry around the x axis involved for the usual properties of addition to hold, another complication, let's sweep it under the rug too).

(for A = B, take the tangent of the curve at A ; in R you can see that it works because you can take the limit as B goes arbitrarily close to A : that gives you the tangent ; in a finite field that’s less obvious but the algebraic proof is the same)

So k*G is just G + G + ... + G, k times.

If you want more details, your favorite reasoning LLM can do a better job explaining what I’ve swept under the rug.

1. It’s a learning experience 2. Looking at the chat transcripts, many of those dollars are burned for stupid reasons (Claude often fails with the insertLines/replaceLines functions and break files due to miss-by-1 offset) that are probably fixable 3. Remember that Claude started from a really rudimentary base with few tools — the bootstrapping was especially inefficient

Next experiment will be on an existing codebase, but that’s probably for next weekend.

After interacting with this tool, I decided it would be nice if the tool could edit itself, so I asked (him ? it ?) to create its next version. It came up with a non-working version of this https://gist.github.com/sloonz/3eb7d7582c33e95f2b000a0920016.... I fixed the bug manually, but it started an interactive loop : I could now describe what I wanted, describe the bugs, and the tool will add the features/fix the bugs itself.

I decided to rewrite it in Typescript (by that I mean: can you rewrite yourself in typescript). And then add other tools (by that: create tools and unit tests for the tools). https://gist.github.com/sloonz/3eb7d7582c33e95f2b000a0920016... and https://gist.github.com/sloonz/3eb7d7582c33e95f2b000a0920016... have been created by the tool itself, without any manual fix from me. Setting up the testing/mock framework ? Done by the tool itself too.

In one day (and $20), I essentially had recreated claude-code. That I could improve just by asking "Please add feature XXX". $2 a feature, with unit tests, on average.

Loaded question (well, affirmation), on a confident sneery tone while using poorly defined terms ("essential humanity") and very poor comprehension of object-level facts of the ground ("Markov chains"). And no sign of even trying to understand the other side, just trying to score rhetoric points on a internet board.

Yes they do.

https://docs.google.com/forms/d/e/1FAIpQLSf5FqX6XBJlfOShMd3U...