It has access to a python interpreter and can use that to do math, but it shows you that this is happening, and it did not when i asked it.

That's not what I meant.

You have access to a dictionary, that doesn’t prove you’re incapable of spelling simple words on your own, like goddamn people what’s with the hate boners for ai around here

??? You just don't understand the difference between a LLM and a chat application using many different tools.

"Measure" is meant in the specific sense of measure theory. The prototypical example is the Lebesgue measure, which generalizes the intuitive definition of length, area, volume, etc. to N-dimensional space.

As a pseudo definition, we may assume:

1. The measure of a rectangle is its length times its width.

2. The measure of the disjoint union of two sets is the sum of their measures.

In 2), we can relax the assumption that the two sets are disjoint slightly, as long as the overlap is small (e.g. two rectangles overlapping on an edge). This suggests a definition for the measure of any set: cover it with rectangles and sum their areas. For most sets, the cover will not be exact, i.e. some rectangles will lie partially outside the set, but these inexact covers can always be refined by subdividing the overhanging rectangles. The (Lebesgue) measure of a set is then defined as the greatest lower bound of all possible such approximations by rectangles.

There are 2 edge cases that quickly arise with this definition. One is the case of zero measure: naturally, a finite set of points has measure zero, since you can cover each point with a rectangle of arbitrarily small area, hence the greatest lower bound is 0. One can cover any countably infinite set with rectangles of area epsilon/n^(2) so that the sum can be made arbitrarily small, too. Even less intuitively, an uncountably infinite and topologically dense set of points can have measure 0 too, e.g. the Cantor set.

The other edge case is the unmeasurable set. Above, I mentioned a subdivision process and defined the measure as the limit of that process. I took for granted that the limit exists. Indeed, it is hard to imagine otherwise, and that is precisely because under reasonably intuitive axioms (ZF + dependent choice) it is consistent to assume the limit always exists. If you take the full axiom of choice, you may "construct" a counterexample, e.g. the Vitali set. The necessity of the axiom of choice in defining this set ensures that it is difficult to gain any geometric intuition about it. Suffice it to say that the set is both too "substantial" to have measure 0, yet too "fragmented" to have any positive measure, and is therefore not well behaved enough to have a measure at all.

78wpm 92% gboard

~200wpm on a physical desktop keyboard

Geometry is a bit tricky. A lot of "obvious" facts about geometry are less obvious to prove from a given collection of axioms forming a model of geometry, because their "obviousness" stems from our natural facilities for understanding space and position. Sometimes, historically, things that are "obviously" true in geometry turn out to be false, or depend on unwritten assumptions, for complex reasons. It may be surprising in this light if current AI can beat humans' intuition plus logic using purely analytic tools.

Ubuntu LTS

More like RHEL 5

I'd rather have an explicit time zone any time a datetime is being passed around code as a string. Communicating it to a human is relatively safe since even if there's a mistake, it's directly visible. Before that last step, incorrect time zone parsing or implicit time zone assumptions in code that was written by "who knows" in the year "who knows" can be really annoying.

https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/addressing-merge-conflicts/resolving-a-merge-conflict-using-the-command-line

What is ridiculously difficult to understand?

Whichever you want. It doesn't really matter.

It's obviously not "just" luck. We know LLMs learn a variety of semantic models of varying degrees of correctness. It's just that no individual (inner) model is really that great, and most of them are bad. LLMs aren't reliable or predictable (enough) to constitute a human-trustable source of information, but they're not pure gibberish generators.

Composable querying/pushdown is nice but transaction management is huge. It's not an easy task to correctly implement a way to share transactions between methods and between repository classes. But the alternative is, your transactions are limited to individual methods (or you don't use them, and you risk leaving your database in an inconsistent state without manual cleanup).

FWIW CertBot does send an email when your cert is about to expire, and then renews it for you.