It’s not really a meaningful question whether the sum Alice received was the fraction of a “coin” I received from you

Ish. If you received a million CSAM’n’heroin bucks, and you give 10 bucks to Alice, there’s a transaction history that now links Alice’s wallet to CSAM’n’heroin which can indeed be a problem for Alice, because cautious exchanges might now freeze her assets until she can offer some proof that she’s not doing anything bad.

There’s a bitcoin wallet attack that uses this trick that was mentioned recently, maybe here, maybe on web3igjg. You can argue the bitcoins aren’t the same, but in practise no-one cares.

eta: this is apparently called a “dust attack” and I first heard about it here: https://awful.systems/post/3463061

Merely interacting with a sanctioned wallet is enough to get or treated with suspicion, let alone receiving funds. Pecunia certainly olets these days.

I thought the era of scaling was over. We’re in the era of ??? now. Presumably profit comes later.

no Gen 1 crypto

Just one more gen, bro. I swear it will fulfil all the promises this time.

I am horrified and somewhat embarrassed that I understood what all that stuff was.

I spend an inordinate amount of time at my C# day job adding documentation comments about exclusive access and lifetimes and ownership… things which are clearly important but which dotnet provides little or no useful support for, even though it has a perfectly good garbage collector. The dotnet devs were well aware that garbage collection has its limits, especially when interacting with resources managed outside of the runtime, and so they added language features like IDisposable and finalisers and GCHandle and SafeHandle and so on to fix some of the things GC won’t be doing for you.

I’d happily use a garbage collected language with borrow checking.

If you don’t have a perf requirement like “all these things need to be in contiguous memory” then you probably don’t need a generational index anyway… it is effectively a weak reference, after all. ECS stores are optimised for repeatedly iterating over all the things, and games might have complex notions of “reachability”, but most things aren’t like that. There does seem to be a lot of “I don’t like using Rc RefCell” in object arena design that isn’t always justifiable, though nested generics don’t make for the most readable code in the world.

You can always use something like generational indices. They pop up a lot in ECS systems. A suitable container with an opaque index type prevents creation of invalid references, lets you check reference validity at runtime, and generational indices prevent reuse. The compiler can’t help with lifetime tracking, but that’s a problem with any shared reference type pointing to a resource with a lifetime that can only be known at runtime, eg. Arc.