On a task with 6.8 percent positives, every threshold I tried scored within 0.8 points of the same accuracy while recall fell from 19.6 percent to 0.6. Answering never at all scores 93.2. The confusion matrix separates these models instantly and the single number cannot tell them apart at all.
I declared one function twice and timed the 2 copies against each other. On a single pair of rounds the identical code showed a 32.9 percent win, 10.6 percent of pairs produced a winner by more than 5 percent, and the first round of all ran 3.57 times slower than the settled median. Anything under about 3 percent on this machine is not a result.
Benford's law is sold as a screen you point at a column of numbers. I pointed it at 4 columns from one repository, where nobody had any reason to fake anything. 3 of them failed. Worse, the 2 standard tests disagree with each other on the same data: the one column MAD lets through is the one chi square rejects.
I set out to measure how retries knock over a service under load. They do triple the traffic, 2.88 times in my rig, but they did not cause the collapse. The collapse was already there at 1.2 times capacity, because the queue got deeper than the client timeout and the server spent its whole day finishing requests nobody was waiting for.
I used to say that a request without a timeout waits forever. Half of that is wrong. The kernel hands you a connect timeout whether you ask for it or not, and on this machine it fires after 135.3 seconds. The other half is worse than forever: once the connection is up, nobody is counting at all.
The fixed window counter leaks double at the boundary, which is the famous flaw. It also needs somebody who knows where the boundary is. The token bucket I switched to instead leaked 199 in a single window against ordinary steady traffic. Only the sliding log held the limit in all 4 traffic shapes, at 50 times the memory.
A single insert at the front of the order made the second page start with the last row of the first one. Both queries are correct. Paging by offset also reads 900020 rows to return 20 at the deep end, taking 69.5 ms against 1.5 for the same page fetched by key, and the plan says so out loud.
On a 4 core server I produced a load average of 8.19 with the processor at 99 percent and a load average of 8.10 with the processor doing real work 36 percent of the time and 7 processes stuck on the disk. Same alarm, opposite fix. And after a full minute of 4 pegged cores the 1 minute figure still read 2.67.
I walked the dependency graph of 6 packages as the registry recorded them today. Grunt brings 51 packages written by 32 people. The small blocks pitch is literally true, since 40 of the 67 packages have no dependencies at all, but 56 of those 67 have exactly 1 maintainer and 3 names account for 26 of them.
I read every zone in the database for 2011 and refined each jump to the minute. 336 of the 344 jumps are the familiar hour. The other 8 are 30 minutes, 2 hours, 3 hours and twice 1440 minutes: on 30 December, 9 days from now, 2 zones lose the whole day. And 26 zones will finish the year an hour away from where they started it.
16 bytes against 8 is 40 percent more index. Arrival order adds another 23 percent on top of that, plus 3 times the insert time once the index outgrows shared_buffers.
5 plumbing calls make a commit that git log reads. 11 revisions of one 1703 line file cost 187576 bytes loose against 16490 packed. The delta base turns out to be the newest version of the file.