SkiFire13

This is pretty much a PCI DSS requirement for anyone that directly handles PANs.

There is also an additional (usually pretty high) fee for getting chargebacks.

There are also "network tokens" that allow you to skip this step and instead remain linked to the new credit card when it changes.

> If you committed a row update but didn't update the index, a subsequent query using the not yet updated index would not find the updated row correctly.

I wonder if you could make it so that queries read from both the index and the unindexed changes. It would be slightly slower but as long as the unindexed changes are kept small it might be fine.

I have to make the mandatory mention of Typst, I found it to cover almost all the markup capabilities that Latex has, while being much more approachable, especially to programmers used to other scripting languages (e.g. Javascript).

> I see http_client as existing in a Reader monad that contains an allocator and an IO interface. This is exactly how the IO monad (and for that matter IO#) works in Haskell. The fact that the Zig people came up with this independantly speaks not just to the universal nature of monads (and the algebraic structures of programming languages)

Honestly this sounds like monad bullshit. That's a struct/class/ADT/whatever you want to call it, they existed since forever. The only idea Zig had was that maybe we shouldn't make them global instances.

Some languages still colloquially refer to cars with the same word used for machine.

That link shows the number of PRs created to be less than 10M though.

> Your engineers who all have to possess AWS or similar certs

If you're using managed services that are so complex you need certified people then you're doing it wrong

Yes, naming does play a role here, but the biggest hint is `as_vec_mut` returning a reference. For that to work a `Vec<u8>` needs to exist somewhere, and continue to exist after this function returns. For comparison, `to_` conversions generally just return the new data, so this reasoning doesn't apply to them.

> String, which is literally (under the hood, you can't poke this legitimately) Vec<u8>

`String::as_vec_mut` kinda implies that, since it gives you access to that underlying `Vec` which must then exist somewhere.

You can definitely have a race condition in JS. Being single-threaded means you don't have parallelism, but you still have concurrency, and that's enough to have race conditions. For example you might have some code that behaves differently depending on which promise resolves first.

I'm not sure about this. In general I see more criticism of GNOME than praise, so if anything the perception would be that GNOME is not a good DE.

> Why do we still put up with GNOME?

Because maybe not all people have the same preferences as you?

> I guess if you run the source code through the model a 10,000 times, some useful stuff falls out.

But you might also get a lot of non-useful stuff which you'll need to sort out.

I'm not sure if they all charge a percentage of your money transfers for that. At work we decided to migrate that part to an internal system anyway.

Stripe's fees are well above interchange fees (especially in Europe). On top of that Stripe's pricing for other features (e.g. invoicing and subscriptions) is also a percentage, so you end up paying a ton for those features.

If you use them for subscriptions you are effectively locked with them. The cost of migrating to a different provider (including existing subscriptions AND payment methods) plus the risk of something breaking the renewals is too high for most companies.

Expanding the logic to union of intervals looks cool, but what is the complexity of that? Since you introduce the the possibility of an operation on an interval producing two intervals I suspect executing N operations might have an exponential complexity, which unfortunately makes this unfeasible to use for some common intervals applciations like abstract interpretation, unless you start introducing approximations once you have enough intervals.

I'm not disagreeing that's a bad aspect of IPv6, I'm just saying that it's not that big of a issue for its adoption.

Isn't that just the definition?

> Instead they expected humans to parse hex, which no one does

Of all aspects of IPv6 you took the only one that doesn't complicate implementations and can easily be swapped if you wanted.

That depends on the country though. Southern Europe is way behind in terms of IPv6 adoption even by ISPs

IPv6 doesn't require modifications to IPv4 devices, applications, networks etc etc either. You just cannot reach IPv6 networks and devices from them, and the same applies to IPv8. 8to4 is nothing innovative because 6to4 already exists. In the end this proposal has all the disadvantages of IPv6 with less advantages.

And if you want the same address space as IPv6 you need to remember 16 digits. Having them written in decimal won't help you with that anyway.

Even if you tried something like that it will eventually break when other commits are added to main that are not present in PR B, even if those commit don't conflict with neither PR A nor PR B changes.

> Try to rebase it and you're going to be manually looking at every non-conflicting change that ever happened on that branch, for no apparent reason

My "fix" is to do an interactive rebase of PR B on main and drop all of PR A's commits from PR B in the process.

I remember seeing a way to do this automatically, but it requires an option that I never remember. IMO this is kind of the issue with git: a lot of improved workflows sit behind some flags that most people never learn. Interactive rebases work for me because they are one primitive, always working in the same way.

I think older processors used to have a slower implementation for shifts, which made this slower.

Nowadays swisstable and other similar hashtables use the top bits and simd/swar techniques to quickly filter out collisions after determining the starting bucket.

My bad I thought it still used `union`s. I guess I'm not very up to date

FYI small string optimizations are generally implemented using unions.