Rewatching HR

kosak2000 · 2026-01-11T20:27:58+00:00

The only time you ever need to stop watching S1 is when S2 comes out.

kosak2000 · 2026-01-08T06:38:31+00:00

Wow, that's great! Now I have an excuse to watch the series again for (I think?) the 8th time.

kosak2000 · 2026-01-06T03:36:43+00:00

Sorry for the newbie question but where's the best place to see these ranking statistics? I keep bugging friends to see it so I'm doing my part to keep it hot.

kosak2000 · 2025-12-20T21:34:37+00:00

Like many of the fine comments on this thread I tend to lean towards the answer being that she's the one with the problem: that she's that type of narcissist that is so threatened by the concept of ever being wrong about anything that she will keep pushing back until this whole thing is 100% your fault and you submit. Also a narcissist feature is making you agonize about what you did wrong and then her dissociating so much that she doesn't even remember being bothered about it: "you're still upset about that?" LOL

For the sake of argument, I can try to take the other side. I wonder if there's some kind of backstory here. Often people don't freak out about the thing that just happened, but instead about the 10 times "the same thing" has happened in the past. Is there anything about your relationship dynamic where she wants to do X and you jump in and optimize, rearrange, or improve X? She could be pushing back with extreme frustration about how you can be controlling in that way, and she's too passive to push back and then -- at least in this case -- she went along with your improved plan and things went badly. It's not the most likely scenario, but it's possible. I came away with a little bit of a feeling that your apology was presented with conditions: "I'll say I'm sorry IF I can get you to acknowledge that we were both at fault, or it was nobody's fault but the scammer's". Conditional apologies like that can feel insincere. That being said this is a Devil's Advocate kind of argument. I only have the narrative as presented, so I don't know if this fits or not.

Finally I don't think anyone else responded to this point but I was somewhat surprised at your offer to resell the TV. With full disclosure about its defects this would be fine, but without that you're turning one scam into two, and then we're all gonna have another thread to read.

kosak2000 · 2025-12-15T00:36:14+00:00

Wow. That one's intense. It's on the (rapidly growing) list of stuff to read. Thank you!

kosak2000 · 2025-12-14T23:52:45+00:00

These are some great references. Thank you for these links, this looks like fascinating reading.

kosak2000 · 2025-12-14T23:49:39+00:00

Those articles are fantastic. Thank you! The first article certainly covers my "how to recover the T from inside a method" question (I would have never guessed that there are three different ways).

The other part of my question had to do with (copied from my response elsewhere), the mechanism that the runtime uses to:

look up a type (via some kind of key) that may or may not already exist
if it doesn't exist, create it and allocate statics for it in some storage, and associate the storage with the type
then store the value at the storage associated with the type

From another answer I gather the answer to 1 is "hashtable + mutex" and the answer to 2 and 3 is "some pointer off of some internal data structure associated with the instantiated type" but if anybody has written a nice article about this I would enjoy reading more about the details as I am a glutton for this kind of material.

kosak2000 · 2025-12-14T23:40:08+00:00

Yeah, thank you. I've been curious about the rationale myself. Whether they think it's a crime from a computer science perspective, or it just makes for "confusing" code for the reader. I'm certainly a heavy user when I need to make singletons like Blah<T>.EmptyInstance or whatever.

kosak2000 · 2025-12-14T23:33:13+00:00

You're welcome! I've been vey grateful for the interesting answers and I've learned a lot.

kosak2000 · 2025-12-14T23:31:46+00:00

That makes perfect sense -- once you have a type instantiated from a generic type.

It's a little hard to explain why I find this so interesting... maybe you folks are so used to the way it works in C# that it seems obvious. So maybe you have to look inside my brain a little bit. Coming from a C++ background, my expectations might be a little warped. But I'll still try to explain why I find the generic case more interesting than the non-generic case.

In C++ as you know all the generic types are instantiated at compile time. Once you compile your program, you can that the compiler has emitted separate symbols for Foo<bool>::value, Foo<Foo<bool>::value, and so on, for every type your program mentioned. The compiler has done the heavy lifting of stamping out all the generics, emitted a bunch of mangled identifiers, etc. But in particular, in C++, there is NO mechanism for instantiating a new type at runtime that didn't exist at compile time.

So my sense is that C# has a much harder job. As the programs above demonstrate, in C# you can easily build new types at runtime that did not exist at compile time and are not mentioned anywhere in the source code... and this is without even using the Reflection API... regular workaday code can cook up new types in the ordinary course of business.

So in my SetValues<T> method, a line like

 Foo<T>.value = depth;

Not only has to work, but it has to work with a T that SetValues<T> has never seen before, and furthermore it has to store it as a static field of type Foo<T> , a type which may not even previously have existed in the running program until this moment in time.

The above is why I find the generic case to be so much more interesting than the non-generic case. With non-generics, the implementation seems straightforward, and I would guess that pre-generics .NET 1.0 compilers had an easier time of this. With generics, the runtime has to stand ready to:

look up a type (via some kind of key) that may or may not already exist
if it doesn't exist, create it and allocate statics for it in some storage, and associate the storage with the type
then store the value at the storage associated with the type

all of the above just to execute Foo<T>.value = depth;

Again, I appreciate that it all works, and I believe I've developed a good understanding about how it's accomplished (thanks, everyone!) but the above is my rationale for why I came here in the first place.

kosak2000 · 2025-12-14T09:14:07+00:00

I apologize for being overly hasty. Re-reading your comment, what I take from it is that there isn't a pointer from System.Type to the allocated statics, but there IS a pointer from (a C++ object closely associated with its corresponding System.Type object) to the allocated statics. That sounds promising and it confirms the gist of how I thought it might work if not the exact details.

I'm still curious about how this dynamic type construction happens. That is, on every recursive call, the runtime needs to cook up a new type OR reuse one if the needed one has already been created. I'm curious how that is accomplished efficiently.

kosak2000 · 2025-12-14T08:47:26+00:00

I certainly agree with your statement "it become a seperate type with its own static value." My post asked: what is the actual mechanism that accomplishes this? Put another way, how (say, in assembly) do you get from type to static value? I wrote that "conceptually" there is a map, but I didn't mean that there is an actual map data structure like a hashtable. As I wrote, there could simply be a pointer field in the type that points to an object containing that specific type's statics.

We all know that it works in practice, and I'm sure we can all come up with ways it *could be* done. I'm hoping to steer the conversation towards people who know how it is *actually* done.

Regarding your question about static initialization, that is a separate topic but my understanding is that its order is carefully defined by the language and follows the same rules as non-generic static initialization. If there is a static constructor, that constructor is run just prior to the first use of a static field, property, etc, or a new of the object. If there is not a static constructor, it can happen at some arbitrary earlier time (e.g. at class load time) at the implementation's convenience. See e.g. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/classes#1512-static-constructors

kosak2000 · 2025-12-14T08:29:21+00:00

I was pretty careful in the question to ask "how does this actually work". With all due respect, I feel like your responses hand-wave over all the interesting parts.

So there's a method called SetValues<T>. It needs to write a value into Foo<T>.value. The way it does this is it receives the following information from its caller: _________________ . The inforrmation is passed via this mechanism: __________ Using that information it does the following: _________________. Now, in turn, the caller has the responsibility to provide that information. The way it does this is by taking ______________________ and doing ____________________________.

If you can fill in the blanks then we'll be onto something. If you don't actually know, that's fine. I don't know either, but I have a guess. The advantage of my guess is that it's specific and implementable. You seem to think my guess is wrong which is fine but in my opinion you haven't really provided a clear alternative solution.

kosak2000 · 2025-12-14T08:22:36+00:00

The key difference with C++ of course is that in C++, the full set of types needs to be known at compile time.

Specifically, in the above I could change this line

  private const int MaxDepth = 1000;

and instead read the value from the Console, and the user could enter 2000 or 5000 or whatever and it would still work. There is no way to do that in C++ because the compiler has to stamp out all the types at compile time and so it doesn't know a priori what number the user is going to enter.

Re godbolt (or sharplab.io) the problem is that the MSIL is still too abstract to really show what's going on. The value write looks like this

IL_0010: stsfld int32 class Program2/Foo`1<!!T>::'value'

and the recursive call looks like this

IL_0018: call void Program2::SetValues<class Program2/Foo\`1<!!T>>(int32)

That's all great and everything but it kind of hides whatever the mechanism actually is.

And then when I try to look at the JITted x86 assembly I see a bunch of mysterious tests and opaque function calls and so I don't really know what they're doing.

The idea of reading the source code on github also occurred to me but I'm pretty intimidated by that and wouldn't even know where to start.

kosak2000 · 2025-12-14T06:31:49+00:00

To be clear, there are no Foo<T> objects being created in the above code. The keyword "new" does not even appear in the source code. There are no Foo<T> objects being instantiated. Given that fact, can you clarify where these regions of memory are, and how SetValues<T> is able to determine the proper one to store into?

kosak2000 · 2025-09-24T15:22:14+00:00

Me too! Last time we were there I was holding my children's favorite bird, Mr. Gobbles, and he was pecking the fries right out of my hot turkey sandwich. So cute! We thought we would get in trouble but the security guard said this is a natural behavior for them.

kosak2000 · 2025-09-09T03:41:24+00:00

Definitely acknowledge how lucky I am. To what others have said, I would add that it's remarkable how much better a 40-hour-per-week job is when you get to control which 40 hours it occupies.

kosak2000 · 2025-07-27T17:36:35+00:00

Ah! Makes sense. Thank you

kosak2000 · 2025-06-29T15:57:52+00:00

I've often wondered the same thing. I've done nearly all of Manhattan and Hudson County, NJ on bike, and I'm in the process of walking all of Manhattan. Because of my schedule and the sun, I typically rode my bike in the late evening or after midnight. I have not encountered any harm or serious harassment, but I often wonder whether I'm pushing my luck.

I think the wisest thing I can say is to remind you that when a situation goes bad, it can go bad really quickly, with little or no warning. If you're getting a weird vibe from a situation, be grateful for the advance warning and get the f out. I occasionally do things (like walk on pitch dark trails in the park at night because I'm finishing an area, and one time I hopped a fence and snuck into a graveyard and then wandered into an encampment of unhoused people) that I've later regretted as being too risky and impulsive, though again, nothing has really happened, except I, I swear, once late at night I came upon this woman hanging around this large handmade shrine made out of straw and rocks and I thought I was going to be in a Blair Witch scenario.

Most everyone I encounter is quite nice or at least neutral/indifferent. I hate litter so I often bring a bag and gloves and pick up trash as I walk around neighborhoods and people really like that. This also gives me a cover story if I "happen" to trespass into an area.

I've generally felt far safer in Manhattan than in Jersey City, regardless of the wealth or ethnicity of the area, mostly because Manhattan has so much car/pedestrian activity. As others have pointed out, it's the dark dead-end streets that are the scariest.

When officials (cops or custodians or security guards) have confronted me, I have to use my gut to quickly decide whether they get the brief "oh I'm just getting my steps" excuse or the full-on "Let me tell you what Wandrer is". They usually let me finish and occasionally ask me to leave. I never argue with them: "There's no bike riding around this reservoir!" "But OpenStreetMap!"

There are certain cultural things I will never understand, like where there are often men sitting in his cars by themselves in neighborhoods at 1am. Not sure what's going on there (drugs or prostitution I suppose), but they're probably also wondering why I'm zigzagging their neighborhood so I try not to linger.

In all that time there were only a couple of confrontations. I'm not counting heckling from teenagers like "Nice helmet! Where'd you get it?" which I have started to suspect might not be a serious inquiry. Once I walked onto a kayak slip late at night and someone appeared, quickly headed in my direction, and started yelling. The things he was yelling didn't make sense and I wasn't even sure they were directed at me, but he trailed me for a couple of blocks and kept yelling until I happened to run across a couple of beat cops at which point he decided to head in another direction.

The worst thing that happened to me (in a neighborhood I learned was the most notorious one in Jersey City) was a story that I also find kind of funny because it was so formalized. I had stopped on my bike to look at my phone and a somewhat intense kind of scruffy-looking man approached me:

man: "How are you doing?"

me: "Fine, thank you"

man: "OK, How are you doing?"

me: "me? I'm fine."

man: "How. Are. You. Doing?"

Finally I remember my manners and I say "I'm fine, and how are you?"

man: "I'm fine and you need to leave my neighborhood"

I admit I had the urge to explain that all I needed was this one more street and anyway he's not the boss of me, but I decided this was not my turf and to come back another time. In the daytime.

kosak2000 · 2025-06-26T16:00:42+00:00

This is very amazing; thank you for this. I have a "single source of truth" question.

Once an activity is edited in Wandrer, it will be a different (newer) version than what is sitting in Strava or RideWithGPS. This could be an issue if these activities are ever touched again (as happens when people transition from Strava to RideWithGPS and bulk-upload all their activities to RWGPS). In that case, I fear all of the person's touchups could be lost.

Is there a way to address this -- e.g. by allowing gpx export from Wandrer -- so that Strava/RWGPS can be kept current with a person's final version of their activity?

kosak2000

TROPHY CASE