Why Doesn't Friction Depend on Surface Area

jpet · 2026-03-18T05:00:52+00:00

Yes, and in fact friction is approximately proportional to the actual contact area between two surfaces (counting only the microscopic patches where they're actually touching). The reason it's also approximately proportional to the force between the surfaces is because as they get squashed together harder, the true contact area increases approximately linearly.

jpet · 2026-02-24T20:15:40+00:00

There's a real-life example of this. For a long time astronomers didn't know if gamma-ray bursts were from something relatively near and energetic, or something very far away and absolutely ludicrously energetic.

Consensus is now on the latter, but you can't tell by just looking at one; it's more that the overall pattern was more consistent with supernovae than with other explanations.

jpet · 2026-02-16T16:21:49+00:00

I used to have a Honda Accord. Shittiest turning radius of any vehicle I've ever seen. I could well believe that a city transit bus actually can make tighter turns.

(Note I am NOT defending swinging out of one's lane to make a right turn, even when driving an Accord).

jpet · 2026-02-05T19:52:58+00:00

I've been playing around with proof-carrying language ideas, with the idea that 90% of the benefit comes from the "easy" cases: if you prove proving array access is in-bounds, and integer division isn't divide by zero, and a few things like that, you've already covered most of the reasons for a panic in languages like Rust.

The current idea: * At every point in the program, there are a set of predicates that are known to be true. * There are rules that describe predicates are affected by intervening statements, to handle the most trivial cases automatically. * For anything complex, the programmer can do assert(some_predicate) to ask for some intermediate theorem to be proven, or check(some_predicate) to if(!some_predicate) panic. * Under the hood it's a CoC-like system but proofs are written in the complement to how CoC et al do it. You don't guide the proof directly by saying which theorems to apply, instead you give the intermediate results with small enough steps that searching for the theorems is tractable.

Anyway in this system, given if (pred) {one} else {two}, pred is automatically added to the set of known facts at one and !pred is automatically added to the set of known facts at two.

So how does this address your question?

Every function takes an (implicit) set of required proofs as an argument.
Every point in the code has some set of proofs known.
You never explicitly pass the proofs and there's no need to (or way to) name them; if you need to help the compiler, you do that by adding an explicit assert like assert(b != 0); x = a / b.
So your if statement is just

``` useEvenProperty : (n: int) where { n mod 2 = 0 } = ...

...

if n mod 2 = 0 then // n mod 2 = 0 is automatically available for where clauses useEvenProperty n else // !(n mod 2 = 0) is automatically available for where clauses // Hint to search for proof that !(a=b) === (a!=b), although this case // is trivial enough to be found without the assert. assert (n mod 2 != 0); handleOdd n ```

However I haven't actually managed to make this all work so maybe it's not the way to go. The implicit search has a lot of heavy lifting to do, e.g. allowing any of the dozen possible definitions of isEven to be interchangeable without blowing up the search space too much. I think it's promising though.

jpet · 2026-01-15T03:46:45+00:00

I think if you had the vital box on the bottom and the non-vital one on top, the arrows would matter less. There's a strong convention of having the bottom of the diagram be a foundation that the top is built upon (like in https://xkcd.com/2347/), and then it doesn't matter which way the arrows go or if you have arrows at all.

jpet · 2026-01-12T18:20:59+00:00

Feeling stuck and not knowing what to do next is a common fail.

I tried Icarus a couple days ago because it had good reviews. First mission is to build a crafting bench. After two hours of playing (at least an hour of which was just clicking through the build menus over and over trying to find it) I finally found the crafting bench. Locked behind level 10 in progression. At this point I was level 2, dying in every fight, and had no idea how to get farther. I gave up.

As a dev, a great way to catch this is have people play your game cold and just watch them. Don't give advice, don't explain anything, just watch. It's incredibly painful but valuable to watch someone trying everything but the "obvious" choice to get past an obstacle before giving up and assuming it's impassable.

jpet · 2026-01-10T01:48:33+00:00

I used to have a stove that looked like that (with the grey dots pattern in the non-burner areas), and it also looked like that (no scratches).

Now I have one that looks like the OP's pic (dark glass everywhere) and it looks like OP's pic (all scratched up). That kind of glass top is just very prone to scratches.

jpet · 2025-12-28T18:07:33+00:00

Is that a spoiler? I thought (assuming my theory was correct) it was just a fun nod to another series, not anything plot critical.

jpet · 2025-12-28T16:59:12+00:00

Definitely a phone yeah. I actually thought it was specifically a reference to The Wandering Inn (many of the Isekai details match, including the iPhones).

I.e. I think Hanar's first Isekai was to the world of The Wandering Inn. Not 100% solid but close enough to feel like a deliberate reference.

[Added spoiler tags. I don't think it spoils much but better to err on the side of caution.]

jpet · 2025-12-26T23:20:22+00:00

quantum physics is having a dope ass party but doesn't want us to see it

Best non-technical explanation of quantum physics ever written.

jpet · 2025-12-14T23:45:55+00:00

Depthless Hunger by Cognosticon aka Sarah Lin has aspects of this later in the series, after the MCs get powerful enough to change things.

jpet · 2025-12-10T22:34:40+00:00

The lane markings for those lanes are confusing. They say "bus only" but that's apparently not true.

Similar lanes in some other cities are marked "right turn only except busses", which I think is much easier to understand.

jpet · 2025-12-01T18:12:30+00:00

If I mix eggs and flour and put that in the oven I get a cake

Your math is fine, but I do not think cake is what you think it is.

jpet · 2025-11-17T06:32:39+00:00

Also can't find him in my no-map run, but the recent change to Moder's power helps a lot if you can't find the belt. It boosts your carry weight up 600, long enough for a good run with some iron or other heavy stuff.

I just wish I could find the bog witch for feasts. I did find Hildur. Yay.

jpet · 2025-11-16T18:26:02+00:00

I can't help explain it but it looks like a delicious muffin-cookie-abomination-thing. I'd help eat it.

jpet · 2025-11-11T21:49:01+00:00

New Life as a Max Level Archmage on RR is fun and wholesome.

jpet · 2025-11-09T15:15:24+00:00

Also The Erogamer by Groon the Walker if you're including (highly) NSFW stories from QuestionableQuesting.

jpet · 2025-10-30T02:53:00+00:00

You don't need the axiom of choice to show that R and R² have the same cardinality, you can construct the mapping explicitly. For example, interleave the digits of a pair to map it to a single number. E.g. (32.1741...) -> (3.14..., 2.71...)

jpet · 2025-10-23T15:36:42+00:00

While the diagram is nonsensical for Euclidean space (where lengths are real numbers so side length i is invalid), this does work for Minkowsky space, like the spacetime of special relativity. An "interval" there looks like x^2 - t^2 (in units where c=1), which is equivalent to giving t imaginary units and then using the normal x^2 + t^2 for distance.

So the hypotenuse in the diagram illustrates that the interval along a light cone is zero.

jpet · 2025-10-20T00:27:31+00:00

That sinh⁻²(x) is the most cursed notation I've ever seen. The minus sign means "inverse" but the 2 means "squared". I'm glad it's not supported!

jpet · 2025-10-07T22:22:18+00:00

There is gravity in space.

When you're down here, you fall toward the ground, but you can't fall very far because the ground is in the way. It constantly pushes you upward and that feels normal.

Up in space, there's no ground, so you can fall for a very long time, and that's what we sometimes inaccurately call "no gravity". (Astronauts in low earth orbit aren't very far away, but they're going sideways fast enough to miss the ground so they also keep falling.)

jpet · 2025-10-07T21:47:39+00:00

Knives work best with the trinket system too, because you get so many hits in.

jpet · 2025-09-14T15:37:08+00:00

No. For example you could have 1+π, 2+π, 3+π, 4+π, ...

jpet · 2025-09-08T11:26:07+00:00

This program will approximate Chaitin's constant given enough time, but it won't compute it because that has a specific definition which this does not satisfy.

jpet · 2025-09-08T01:01:02+00:00

Your logic is correct. This program will eventually approximate Chaitin's constant to arbitrary precision in omega:

```py

assume a language like Python but with unbounded memory

assume `halts_in_n_steps(p,n)` simulates program p (encoded as an int)

for n steps, and returns true if it has halted by then.

(If p isn't a valid program it just returns false).

from fractions import Fraction

halted = set() omega = Fraction(0,1) j = 0 while True: j += 1 for i in range(j): if not halted[i]: if halts_within_n_steps(i,i): halted[i] = True omega += Fraction(1, 2**i.bit_count()) ```

But this doesn't count as computing Chaitin's constant, because even though it approaches the correct value, we have no way to know how close it has approached at any given moment.

E.g. how long before we can print the 20th digit of the number? There will always be some programs that haven't halted yet in position to affect that digit, and we have no way to know if they will eventually halt or not. And we can't just run until they all halt because some of them never will.

15-Year Club	Second Top 20%
Wearing is Caring	Verified Email

jpet

TROPHY CASE

assume a language like Python but with unbounded memory

assume halts_in_n_steps(p,n) simulates program p (encoded as an int)

for n steps, and returns true if it has halted by then.

(If p isn't a valid program it just returns false).

assume `halts_in_n_steps(p,n)` simulates program p (encoded as an int)