The point of a CS degree is to know the fundamentals of computing, not the latest best practices in programming that abstract the fundamentals.

If something "carries" or is "a carry", it means it is so strong it metaphorically carries the rest of the setup with it. For example:

> This card carries.

> These two are the carries of the team.

Convolving two arrays can be done perfectly accurately in O(n log n), despite every element being combined with every other element.

Or consider the even more basic sum of products a[i] * b[j] for all possible i, j:

    total = 0
    for i in range(len(a)):
        for j in range(len(b)):
            total += a[i] * b[j]

Your logic that 'the result contains terms of all pairs, therefore the algorithm must be quadratic' simply doesn't hold.

As it fills up the false probability rate goes up. Once the false probability rate reaches the threshold of unacceptability, the bloom filter is full, and you can no longer insert into it.

That most interfaces still let you do something that looks like an insert is an interface failure, not a bloom filter feature.

If you find this controversial and want to reply "I don't have a threshold of unacceptability", I'll counter that a false probability rate of 100% will be reached eventually. And if you still find that acceptable, you can trivially modify any probabilistic filter to "never become full" by replacing the "is full" error condition with setting a flag that all future queries should return a false positive.

In my experience agents don't converge on anything. They diverge into low-quality monstrosities which at some point become entirely unusable.

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

Points: 3

# Comments: 1

I almost never even think about the borrow checker. If you have a long-lived shared reference you just Arc it. If it's a circular ownership structure like a graph you use a SlotMap. It by no means is any harder for this codebase than for small ones.

> how productive power users in different [fields] can be with their tools

There are a lot more tools in programming than your text editor. Linters, debuggers, AI assistants, version control, continuous integration, etc.

I personally know I'm terrible at using debuggers. Is this a shortcoming of mine? Probably. But I also feel debuggers could be a lot, lot better than they are right now.

I think for a lot of us reflecting at our workflow and seeing things we do that could be done more efficiently with better (usage of) tooling could pay off.

For example if I were to give $1 to every person on earth, but $100 million to you, everyone would be richer but you would be a lot richer still.

(not me, but...)

Bach - Passacaglia & Fugue in C minor, BWV 582

> But one wonders what he could have made without those constraints.

Bach-Busoni - Chaconne from Partita No. 2 in D minor, BWV 1004

Loss happens, firings are a decision.

In most cases it's even better to just store a maximum per thread separately and loop over all threads once to compute the current maximum if you really need it.

It is if you use alignment bits. Not always possible if you don't control the data though.