crotchfire

https://www.cardlogix.com/product-tag/ecdsa/

It's the same software used by the official Linux Kernel Mailing Lists: https://lore.kernel.org/

- It lets people `git clone` the archives and then `git pull` from them incrementally, so you get the same "distributed backups" that git provides.

- It also provides high-quality (Xapian) fulltext search, RSS/Atom, and NNTP access.

- It doesn't artificially fracture mailing list threads at month boundaries. I know this sounds like a trivial feature, but I'm constantly astonished that most other mailing list archive software does this. It's so irritating.

- Most important of all, it provides a smooth migration path away from SMTP-push for mailing lists, which has always been the big headache. Most of the problems with email go away when you switch from push to incremental-pull. Unsurprisingly, git is the perfect tool for doing incremental pull.

Unfortunately every single one of his books has this problem. It's like all of his novels are written from the perspective of the protagonist's housecat.

The third book -- while not nearly as good as either Fire Upon The Deep or Deepness in the Sky -- had even more fascinating insights into the practical mechanics of a group mind with physical bodies. Like the fact that romance happens on two separate levels!

But how do they decide when to expand a datacenter or build a new one?

The demand is priced in quotons but the costs are in dollars.

Somebody somewhere at google must be maintaining a quoton/dollar exchange rate. It's weird that it's hidden from the rest of the company.

> so internal teams can be compared with a common currency

What's wrong with comparing them using dollars (or euros or whatever) as the currency? That's what Google's revenues are measured in terms of. If the price of electricity doubles (like it has in the EU) a team with euro-constant revenues could swing from being highly profitable to a massive loss... and nobody would notice because quotons conceal the cost of electricity.

It makes every single commit as ugly as this one. In other words, instead of only some of your commits being full of formatting noise, all of them are, because touching any line causes rewrapping/reindentation of all the nearby lines.

Running a formatter on every single commit is dumb, unless you're an enormous company that doesn't release their software (i.e. Google and very few other companies).

If you ship your software, make the autoformatter part of the release process. Commit the reformat (to the trunk) right before each branch-off. It's a great compromise. Everything is autoformatted "in the limit" but the disruptive commits happen only once per release cycle. Formatting-only PRs get rejected with "please wait until the next release and/or teach the autoformatter to do whatever it is you want here"

Github is a gigantic pile of javascript that has to execute on your machine.

`Unzip` doesn't execute anything. If you're really paranoid, use an `unzip` tool written in Rust: https://lib.rs/keywords/zip-archive

It only supports IPFS and derivitaves thereof.

This is just a crawler for DHTs that use IPFS's implementation, or at least smell very similar to it.

For all the cloud companies, "quota" is literally dollars. Bandwidth, memory, cpu, these are things they sell. So they are measured in money. The existing corporate budgetary process already manages dollars (indeed, that's its main function). If you want more of one of these things, you'll be displacing some customer who stood ready to pay for them (i.e. on the spot market), so you need to replace the revenue they were providing. Very straightforward.

What does google measure all these things in? Quotons? Where do quotons come from? When google becomes more profitable, does the Central Bank of Quoton print more quotons each month than they had previously? Does Google have a Chief Quoton Officer?

Totally curious about this. Google is the only company operating on this scale that doesn't sell raw bandwidth/cpu/ram as their product, nor do they buy these things from underlying cloud vendors (like e.g. Cloudflare does). This makes a lot of things simpler internally and probably avoids a lot of internal conflicts, but it does mean that they have to have a parallel internal accounting system for this stuff.

Is there an official exchange rate between the two accounting systems? Are different teams allowed to sell each other quotons, in exchange for budget dollars? Has the IRS ever audited Google's Quoton books?

Okay that last question was not serious. But the rest were.

Here's the real output.

    $ ldd result/bin/typst
        linux-vdso.so.1 (0x00007ffd2c4e5000)
        libgcc_s.so.1 => /nix/store/28d6zz06v3mpwdbi72fdw64qmmq8rhfm-gcc-13.2.0-lib/lib/libgcc_s.so.1 (0x00007f4fe68b9000)
        libm.so.6 => /nix/store/7x591g0d1kydp4dci0jvksi0qbn013v3-glibc-2.38-27/lib/libm.so.6 (0x00007f4fe67d9000)
        libc.so.6 => /nix/store/7x591g0d1kydp4dci0jvksi0qbn013v3-glibc-2.38-27/lib/libc.so.6 (0x00007f4fe4619000)
        /nix/store/7x591g0d1kydp4dci0jvksi0qbn013v3-glibc-2.38-27/lib/ld-linux-x86-64.so.2 => /nix/store/7v29y7b3b38x2hpgld698fw6k5mffam8-glibc-2.38-44/lib64/ld-linux-x86-64.so.2 (0x00007f4fe68e1000)

You faked your console output.

"Yeah just use ancient binaries" is not a viable strategy for future-proofing.

It's a lot easier to move fast and break things when you don't care about stability.

Pandoc can "convert" html to things too, but you wouldn't use it as a web browser.

This isn't about fads and trends. If you want to discuss those, find a fashion forum.

It's one of those fractal issues. The more you zoom in, the weirder it gets.

> You may have noticed in the past that context switches are slow

I'm not sure that the situation has improved. In many ways it is getting worse.

TLBs are growing much, much, much more slowly than L2/L3 cache sizes.

This is mainly because on-chip wire delay isn't dropping as quickly as transistor density is rising -- coupling capacitance in densly-wired areas has become a much bigger problem over the last decade. The TLB has to run at the same clock rate as the register file, but it is much larger (both in terms of bits and in terms of geometry).

> But with Java you could at least theoretically do it

Or with a memory-safe, non-garbage-collected language. Hopefully someday we'll have more than one of these. These languages are the final nail in the coffin of microkernels.

I found the only person on hacker news who has never heard of these things called "computers"

!!!!

A few of them accept that they have a cost, but insist that it is totally predictable and deterministic.

You can't talk them out of these beliefs. I have tried. They just get very angry at you.

But people here seem to be unwilling to consider getting rid of their precious phones. So they will keep getting abused.